pi-lens 1.3.13 → 2.0.0

package/clients/dependency-checker.test.ts

@@ -1,44 +1,31 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { DependencyChecker } from "./dependency-checker.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
+import { setupTestEnvironment } from "./test-utils.js";
 
 describe("DependencyChecker", () => {
-  let checker: DependencyChecker;
+  let client: DependencyChecker;
   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(() => {
-    checker = new DependencyChecker();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-dep-test-"));
+    client = new DependencyChecker();
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-dep-test-"));
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
   });
 
   describe("isAvailable", () => {
     it("should check madge availability", () => {
-      const available = checker.isAvailable();
+      const available = client.isAvailable();
       expect(typeof available).toBe("boolean");
     });
   });
 
   describe("checkFile", () => {
     it("should return no circular deps for non-existent files", () => {
-      const result = checker.checkFile("/nonexistent/file.ts");
+      const result = client.checkFile("/nonexistent/file.ts");
       expect(result.hasCircular).toBe(false);
       expect(result.circular).toEqual([]);
     });
@@ -68,7 +55,7 @@ describe("DependencyChecker", () => {
   describe("formatWarning", () => {
     it("should format circular dependency warning", () => {
       const circularDeps = ["b.ts", "c.ts", "a.ts"];
-      const formatted = checker.formatWarning("a.ts", circularDeps);
+      const formatted = client.formatWarning("a.ts", circularDeps);
 
       expect(formatted).toContain("cycle");
       expect(formatted).toContain("a.ts");
@@ -76,7 +63,7 @@ describe("DependencyChecker", () => {
 
     it("should show the circular path", () => {
       const circularDeps = ["b.ts", "a.ts"];
-      const formatted = checker.formatWarning("a.ts", circularDeps);
+      const formatted = client.formatWarning("a.ts", circularDeps);
 
       expect(formatted).toContain("b.ts");
     });

package/clients/go-client.test.ts

@@ -1,22 +1,25 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { GoClient } from "./go-client.js";
+import { setupTestEnvironment } from "./test-utils.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
 
 describe("GoClient", () => {
   let client: GoClient;
   let tmpDir: string;
+  let cleanup: () => void;
 
   beforeEach(() => {
     client = new GoClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-go-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-go-test-"));
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
+  });
+
+  afterEach(() => {
+    cleanup();
   });
 
   describe("isGoFile", () => {

package/clients/jscpd-client.test.ts

@@ -1,32 +1,23 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { JscpdClient } from "./jscpd-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("JscpdClient", () => {
   let client: JscpdClient;
   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 JscpdClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-jscpd-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-jscpd-test-"));
+  });
+
+  afterEach(() => {
+    cleanup();
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
   });
 
   describe("isAvailable", () => {
@@ -60,8 +51,8 @@ function processData(data: number[]): number {
   return sum;
 }
 `;
-      createTempFile("file1.ts", duplicateCode);
-      createTempFile("file2.ts", duplicateCode);
+      createTempFile(tmpDir, "file1.ts", duplicateCode);
+      createTempFile(tmpDir, "file2.ts", duplicateCode);
 
       const result = client.scan(tmpDir, 3, 20); // Lower thresholds for test
 

package/clients/jscpd-client.ts

@@ -73,7 +73,7 @@ export class JscpdClient {
         "--min-tokens", String(minTokens),
         "--reporters", "json",
         "--output", outDir,
-        "--ignore", "**/node_modules/**,**/dist/**,**/build/**,**/.git/**",
+        "--ignore", "**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock",
       ], {
         encoding: "utf-8",
         timeout: 30000,

package/clients/knip-client.test.ts

@@ -1,22 +1,23 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { KnipClient } from "./knip-client.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
+import { setupTestEnvironment } from "./test-utils.js";
 
 describe("KnipClient", () => {
   let client: KnipClient;
   let tmpDir: string;
+  let cleanup: () => void;
 
   beforeEach(() => {
     client = new KnipClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-knip-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-knip-test-"));
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
+  });
+
+  afterEach(() => {
+    cleanup();
   });
 
   describe("isAvailable", () => {

package/clients/metrics-client.test.ts

@@ -1,28 +1,25 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { MetricsClient } from "./metrics-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("MetricsClient", () => {
   let client: MetricsClient;
   let tmpDir: string;
-
-  function createTempFile(name: string, content: string): string {
-    const filePath = path.join(tmpDir, name);
-    fs.writeFileSync(filePath, content);
-    return filePath;
-  }
+  let cleanup: () => void;
 
   beforeEach(() => {
     client = new MetricsClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-metrics-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-metrics-test-"));
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
+  });
+
+  afterEach(() => {
+    cleanup();
   });
 
   describe("calculateEntropy", () => {
@@ -56,7 +53,7 @@ describe("MetricsClient", () => {
   describe("recordBaseline", () => {
     it("should record baseline for existing file", () => {
       const content = "const x = 1;\nconst y = 2;";
-      const filePath = createTempFile("test.ts", content);
+      const filePath = createTempFile(tmpDir, "test.ts", content);
 
       client.recordBaseline(filePath);
 
@@ -74,7 +71,7 @@ describe("MetricsClient", () => {
     it("should not overwrite existing baseline", () => {
       const content1 = "const x = 1;\n";
       const content2 = "const x = 1;\nconst y = 2;\nconst z = 3;\n";
-      const filePath = createTempFile("test.ts", content1);
+      const filePath = createTempFile(tmpDir, "test.ts", content1);
 
       client.recordBaseline(filePath);
 
@@ -92,7 +89,7 @@ describe("MetricsClient", () => {
   describe("recordWrite", () => {
     it("should track agent-written lines", () => {
       const original = "const x = 1;\n";
-      const filePath = createTempFile("test.ts", original);
+      const filePath = createTempFile(tmpDir, "test.ts", original);
 
       client.recordBaseline(filePath);
 
@@ -105,8 +102,8 @@ describe("MetricsClient", () => {
     });
 
     it("should calculate AI code ratio", () => {
-      const file1 = createTempFile("file1.ts", "original content line 1\noriginal content line 2\n");
-      const file2 = createTempFile("file2.ts", "original\n");
+      const file1 = createTempFile(tmpDir, "file1.ts", "original content line 1\noriginal content line 2\n");
+      const file2 = createTempFile(tmpDir, "file2.ts", "original\n");
 
       client.recordBaseline(file1);
       client.recordBaseline(file2);
@@ -126,7 +123,7 @@ describe("MetricsClient", () => {
   describe("getEntropyDeltas", () => {
     it("should track entropy changes", () => {
       const simple = "const x = 1;\n";
-      const filePath = createTempFile("test.ts", simple);
+      const filePath = createTempFile(tmpDir, "test.ts", simple);
 
       client.recordBaseline(filePath);
 
@@ -158,7 +155,7 @@ function complex(a: number, b: number, c: number): number {
     });
 
     it("should format AI code ratio when files are modified", () => {
-      const filePath = createTempFile("test.ts", "original\n");
+      const filePath = createTempFile(tmpDir, "test.ts", "original\n");
       client.recordBaseline(filePath);
 
       const modified = "original\nnew line 1\nnew line 2\n";
@@ -173,7 +170,7 @@ function complex(a: number, b: number, c: number): number {
 
   describe("reset", () => {
     it("should clear all tracked data", () => {
-      const filePath = createTempFile("test.ts", "content\n");
+      const filePath = createTempFile(tmpDir, "test.ts", "content\n");
       client.recordBaseline(filePath);
 
       client.reset();

package/clients/ruff-client.test.ts

@@ -1,28 +1,23 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { RuffClient } from "./ruff-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("RuffClient", () => {
   let client: RuffClient;
   let tmpDir: string;
-
-  function createTempFile(name: string, content: string): string {
-    const filePath = path.join(tmpDir, name);
-    fs.writeFileSync(filePath, content);
-    return filePath;
-  }
+  let cleanup: () => void;
 
   beforeEach(() => {
     client = new RuffClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-ruff-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ruff-test-"));
+  });
+
+  afterEach(() => {
+    cleanup();
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
   });
 
   describe("isPythonFile", () => {
@@ -61,7 +56,7 @@ import sys
 
 x = 1
 `;
-      const filePath = createTempFile("test.py", content);
+      const filePath = createTempFile(tmpDir, "test.py", content);
       const result = client.checkFile(filePath);
 
       // Should detect unused imports
@@ -76,7 +71,7 @@ def foo():
     x = undefined_variable
     return x
 `;
-      const filePath = createTempFile("test.py", content);
+      const filePath = createTempFile(tmpDir, "test.py", content);
       const result = client.checkFile(filePath);
 
       // Should return an array
@@ -124,7 +119,7 @@ def foo():
       const content = `x=1
 y=2
 `;
-      const filePath = createTempFile("test.py", content);
+      const filePath = createTempFile(tmpDir, "test.py", content);
       const result = client.checkFormatting(filePath);
 
       // Should suggest formatting (missing spaces around =)
@@ -137,7 +132,7 @@ y=2
       const content = `x = 1
 y = 2
 `;
-      const filePath = createTempFile("test.py", content);
+      const filePath = createTempFile(tmpDir, "test.py", content);
       const result = client.checkFormatting(filePath);
 
       // Well-formatted code should return empty or minimal output

package/clients/rust-client.test.ts

@@ -1,22 +1,25 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { RustClient } from "./rust-client.js";
+import { setupTestEnvironment } from "./test-utils.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
 
 describe("RustClient", () => {
   let client: RustClient;
   let tmpDir: string;
+  let cleanup: () => void;
 
   beforeEach(() => {
     client = new RustClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-rust-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-rust-test-"));
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
+  });
+
+  afterEach(() => {
+    cleanup();
   });
 
   describe("isRustFile", () => {

package/clients/subprocess-client.ts

@@ -0,0 +1,158 @@
+/**
+ * Base class for CLI tool clients that communicate via subprocess.
+ *
+ * Provides common patterns for:
+ * - Availability checking (cached)
+ * - File type detection
+ * - Running CLI commands
+ * - Logging
+ *
+ * Subclasses implement:
+ * - getToolName(): The CLI tool name
+ * - getCheckCommand(): Command to check availability
+ * - isSupportedFile(): File extensions the tool handles
+ * - parseOutput(): Parse CLI output into diagnostics
+ */
+
+import { spawnSync } from "node:child_process";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+export interface Diagnostic {
+	line: number;
+	column: number;
+	endLine: number;
+	endColumn: number;
+	severity: "error" | "warning" | "info" | "hint";
+	message: string;
+	rule?: string;
+	file: string;
+	fixable?: boolean;
+}
+
+export abstract class SubprocessClient<T extends Diagnostic> {
+	protected available: boolean | null = null;
+	protected log: (msg: string) => void;
+	private toolName: string;
+
+	constructor(verbose = false) {
+		this.toolName = this.getToolName();
+		this.log = verbose
+			? (msg: string) => console.log(`[${this.toolName}] ${msg}`)
+			: () => {};
+	}
+
+	/**
+	 * The name of the CLI tool (used in log messages)
+	 */
+	protected abstract getToolName(): string;
+
+	/**
+	 * Command and args to check if the tool is available
+	 * e.g., ["ruff", "--version"] or ["npx", "@biomejs/biome", "--version"]
+	 */
+	protected abstract getCheckCommand(): string[];
+
+	/**
+	 * File extensions this tool supports (with dots)
+	 * e.g., [".py"] or [".ts", ".tsx", ".js", ".jsx"]
+	 */
+	protected abstract getSupportedExtensions(): string[];
+
+	/**
+	 * Parse CLI output into diagnostics
+	 */
+	protected abstract parseOutput(output: string, filePath: string): T[];
+
+	/**
+	 * Check if the CLI tool is available (cached)
+	 */
+	isAvailable(): boolean {
+		if (this.available !== null) return this.available;
+
+		const cmd = this.getCheckCommand();
+		try {
+			const result = spawnSync(cmd[0], cmd.slice(1), {
+				encoding: "utf-8",
+				timeout: 10000,
+				shell: true,
+			});
+
+			this.available = !result.error && result.status === 0;
+			if (this.available) {
+				this.log(`${this.toolName} found`);
+			} else {
+				this.log(`${this.toolName} not available`);
+			}
+		} catch {
+			this.available = false;
+		}
+
+		return this.available;
+	}
+
+	/**
+	 * Check if a file is supported by this tool
+	 */
+	isSupportedFile(filePath: string): boolean {
+		const ext = path.extname(filePath).toLowerCase();
+		return this.getSupportedExtensions().includes(ext);
+	}
+
+	/**
+	 * Run the tool on a file and return diagnostics
+	 */
+	abstract checkFile(filePath: string): T[];
+
+	/**
+	 * Run a command and return the result
+	 */
+	protected runCommand(
+		cmd: string[],
+		options: {
+			cwd?: string;
+			timeout?: number;
+			input?: string;
+		} = {},
+	): ReturnType<typeof spawnSync> {
+		const { cwd, timeout = 15000, input } = options;
+
+		try {
+			const result = spawnSync(cmd[0], cmd.slice(1), {
+				encoding: "utf-8",
+				timeout,
+				cwd,
+				shell: true,
+				input,
+			});
+
+			if (result.error) {
+				this.log(`Command error: ${result.error.message}`);
+			}
+
+			return result;
+		} catch (err: any) {
+			this.log(`Command failed: ${err.message}`);
+			return {
+				error: err,
+				status: 1,
+				stdout: "",
+				stderr: err.message,
+			} as unknown as ReturnType<typeof spawnSync>;
+		}
+	}
+
+	/**
+	 * Resolve a file path to absolute
+	 */
+	protected resolvePath(filePath: string): string {
+		return path.resolve(filePath);
+	}
+
+	/**
+	 * Check if a file exists
+	 */
+	protected fileExists(filePath: string): boolean {
+		return fs.existsSync(filePath);
+	}
+}