pi-lens 2.0.37 → 2.0.39

package/clients/dependency-checker.js

@@ -95,46 +95,32 @@ export class DependencyChecker {
     importsChanged(filePath) {
         const normalized = path.resolve(filePath);
         if (!fs.existsSync(normalized)) {
-            // File deleted, remove from cache
             this.importCache.delete(normalized);
             return true;
         }
         const stat = fs.statSync(normalized);
-        const mtime = stat.mtimeMs;
         const cached = this.importCache.get(normalized);
-        // If timestamp hasn't changed, imports haven't changed
-        if (cached && cached.timestamp >= mtime) {
+        // Fast path: timestamp hasn't changed
+        if (cached && cached.timestamp >= stat.mtimeMs) {
             return false;
         }
-        // Parse new imports
+        // Compare actual imports
         const newImports = this.extractImports(normalized);
-        const newEntry = {
-            imports: newImports,
-            timestamp: mtime,
-        };
-        // Check if imports actually changed
-        if (cached) {
-            if (cached.imports.size !== newImports.size) {
-                this.importCache.set(normalized, newEntry);
-                return true;
-            }
-            for (const imp of newImports) {
-                if (!cached.imports.has(imp)) {
-                    this.importCache.set(normalized, newEntry);
-                    return true;
-                }
-            }
-            for (const imp of cached.imports) {
-                if (!newImports.has(imp)) {
-                    this.importCache.set(normalized, newEntry);
-                    return true;
-                }
-            }
-            // Imports are the same, just update timestamp
-            this.importCache.set(normalized, newEntry);
+        const hasChanged = !cached || !this.setsEqual(cached.imports, newImports);
+        // Update cache
+        this.importCache.set(normalized, { imports: newImports, timestamp: stat.mtimeMs });
+        return hasChanged;
+    }
+    /**
+     * Check if two sets have the same elements
+     */
+    setsEqual(a, b) {
+        if (a.size !== b.size)
             return false;
+        for (const item of a) {
+            if (!b.has(item))
+                return false;
         }
-        this.importCache.set(normalized, newEntry);
         return true;
     }
     /**

package/clients/dependency-checker.ts

@@ -139,55 +139,35 @@ export class DependencyChecker {
 		const normalized = path.resolve(filePath);
 
 		if (!fs.existsSync(normalized)) {
-			// File deleted, remove from cache
 			this.importCache.delete(normalized);
 			return true;
 		}
 
 		const stat = fs.statSync(normalized);
-		const mtime = stat.mtimeMs;
-
 		const cached = this.importCache.get(normalized);
 
-		// If timestamp hasn't changed, imports haven't changed
-		if (cached && cached.timestamp >= mtime) {
+		// Fast path: timestamp hasn't changed
+		if (cached && cached.timestamp >= stat.mtimeMs) {
 			return false;
 		}
 
-		// Parse new imports
+		// Compare actual imports
 		const newImports = this.extractImports(normalized);
-		const newEntry: FileImports = {
-			imports: newImports,
-			timestamp: mtime,
-		};
-
-		// Check if imports actually changed
-		if (cached) {
-			if (cached.imports.size !== newImports.size) {
-				this.importCache.set(normalized, newEntry);
-				return true;
-			}
-
-			for (const imp of newImports) {
-				if (!cached.imports.has(imp)) {
-					this.importCache.set(normalized, newEntry);
-					return true;
-				}
-			}
+		const hasChanged = !cached || !this.setsEqual(cached.imports, newImports);
 
-			for (const imp of cached.imports) {
-				if (!newImports.has(imp)) {
-					this.importCache.set(normalized, newEntry);
-					return true;
-				}
-			}
+		// Update cache
+		this.importCache.set(normalized, { imports: newImports, timestamp: stat.mtimeMs });
+		return hasChanged;
+	}
 
-			// Imports are the same, just update timestamp
-			this.importCache.set(normalized, newEntry);
-			return false;
+	/**
+	 * Check if two sets have the same elements
+	 */
+	private setsEqual<T>(a: Set<T>, b: Set<T>): boolean {
+		if (a.size !== b.size) return false;
+		for (const item of a) {
+			if (!b.has(item)) return false;
 		}
-
-		this.importCache.set(normalized, newEntry);
 		return true;
 	}
 

package/clients/fix-scanners.js

@@ -0,0 +1,195 @@
+/**
+ * Scanner functions for fix.ts
+ *
+ * Each scanner encapsulates one type of issue detection:
+ * - scanDuplicates: JSCPD duplicate code detection
+ * - scanDeadCode: Knip dead code detection
+ * - scanAstGrep: Structural linting via ast-grep
+ * - scanBiome: Remaining Biome lint issues
+ * - scanSlop: AI slop indicators (high complexity patterns)
+ */
+import * as childProcess from "node:child_process";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { shouldIgnoreFile } from "./scan-utils.js";
+const DEBUG_LOG = path.join(process.env.HOME || process.env.USERPROFILE || ".", "pi-lens-debug.log");
+function dbg(msg) {
+    const line = `[${new Date().toISOString()}] ${msg}\n`;
+    try {
+        nodeFs.appendFileSync(DEBUG_LOG, line);
+    }
+    catch {
+        // Ignored
+    }
+}
+/**
+ * Scan for duplicate code blocks using JSCPD
+ */
+export function scanDuplicates(jscpd, targetPath, isTsProject) {
+    if (!jscpd.isAvailable())
+        return [];
+    const jscpdResult = jscpd.scan(targetPath);
+    return jscpdResult.clones.filter((c) => {
+        if (isTsProject && (c.fileA.endsWith(".js") || c.fileB.endsWith(".js")))
+            return false;
+        return path.resolve(c.fileA) !== path.resolve(c.fileB);
+    });
+}
+/**
+ * Scan for dead code using Knip
+ */
+export function scanDeadCode(knip, targetPath, isTsProject) {
+    if (!knip.isAvailable())
+        return [];
+    const knipResult = knip.analyze(targetPath);
+    return knipResult.issues.filter((i) => {
+        if (!i.file)
+            return true;
+        return !shouldIgnoreFile(i.file, isTsProject);
+    });
+}
+/**
+ * Scan for structural issues using ast-grep
+ */
+export function scanAstGrep(targetPath, isTsProject, configPath) {
+    const hasSg = nodeFs.existsSync(path.join(targetPath, "node_modules", ".bin", "sg")) ||
+        childProcess.spawnSync("npx", ["sg", "--version"], { encoding: "utf-8", timeout: 5000, shell: true }).status === 0;
+    if (!hasSg)
+        return [];
+    const result = childProcess.spawnSync("npx", [
+        "sg",
+        "scan",
+        "--config",
+        configPath,
+        "--json",
+        "--globs",
+        "!**/*.test.ts",
+        "--globs",
+        "!**/*.spec.ts",
+        "--globs",
+        "!**/test-utils.ts",
+        "--globs",
+        "!**/.pi-lens/**",
+        ...(isTsProject ? ["--globs", "!**/*.js"] : []),
+        targetPath,
+    ], {
+        encoding: "utf-8",
+        timeout: 30000,
+        shell: true,
+        maxBuffer: 32 * 1024 * 1024,
+    });
+    const raw = result.stdout?.trim() ?? "";
+    const items = raw.startsWith("[")
+        ? (() => {
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                return [];
+            }
+        })()
+        : raw.split("\n").flatMap((l) => {
+            try {
+                return [JSON.parse(l)];
+            }
+            catch {
+                return [];
+            }
+        });
+    const astIssues = [];
+    for (const item of items) {
+        const rule = item.ruleId || item.rule?.title || item.name || "unknown";
+        const line = (item.labels?.[0]?.range?.start?.line ?? item.range?.start?.line ?? 0) +
+            1;
+        const relFile = path.relative(targetPath, item.file ?? "").replace(/\\/g, "/");
+        if (shouldIgnoreFile(relFile, isTsProject))
+            continue;
+        astIssues.push({
+            rule,
+            file: relFile,
+            line,
+            message: item.message ?? rule,
+        });
+    }
+    return astIssues;
+}
+/**
+ * Scan for remaining Biome lint issues (couldn't be auto-fixed)
+ */
+export function scanBiomeIssues(biome, targetPath) {
+    if (!biome.isAvailable())
+        return [];
+    const checkResult = childProcess.spawnSync("npx", ["@biomejs/biome", "check", "--reporter=json", "--max-diagnostics=50", targetPath], { encoding: "utf-8", timeout: 20000, shell: true });
+    const remainingBiome = [];
+    try {
+        const data = JSON.parse(checkResult.stdout ?? "{}");
+        for (const diag of (data.diagnostics ?? []).slice(0, 20)) {
+            if (!diag.category?.startsWith("lint/"))
+                continue;
+            const filePath = diag.location?.path?.file ?? "";
+            const line = diag.location?.span?.start?.line ?? 0;
+            const rule = diag.category ?? "lint";
+            remainingBiome.push({
+                file: path.relative(targetPath, filePath).replace(/\\/g, "/"),
+                line: line + 1,
+                rule,
+                message: diag.message ?? rule,
+            });
+        }
+    }
+    catch (e) {
+        dbg(`biome lint parse failed: ${e}`);
+    }
+    return remainingBiome;
+}
+/**
+ * Scan for AI slop indicators (high complexity patterns)
+ */
+export function scanSlop(complexity, targetPath, isTsProject) {
+    const slopFiles = [];
+    const scanDir = (dir) => {
+        if (!nodeFs.existsSync(dir))
+            return;
+        for (const entry of nodeFs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (["node_modules", ".git", "dist", "build", ".next", ".pi-lens"].includes(entry.name))
+                    continue;
+                scanDir(fullPath);
+            }
+            else if (complexity.isSupportedFile(fullPath)) {
+                const metrics = complexity.analyzeFile(fullPath);
+                if (metrics) {
+                    const warnings = complexity
+                        .checkThresholds(metrics)
+                        .filter((w) => w.includes("AI-style") ||
+                        w.includes("try/catch") ||
+                        w.includes("single-use") ||
+                        w.includes("Excessive comments"));
+                    const relFile = path
+                        .relative(targetPath, fullPath)
+                        .replace(/\\/g, "/");
+                    if (shouldIgnoreFile(relFile, isTsProject))
+                        continue;
+                    if (warnings.length >= 2) {
+                        slopFiles.push({ file: relFile, warnings });
+                    }
+                }
+            }
+        }
+    };
+    scanDir(targetPath);
+    return slopFiles;
+}
+/**
+ * Run all scanners and return combined results
+ */
+export function scanAll(clients, targetPath, isTsProject, configPath) {
+    return {
+        duplicates: scanDuplicates(clients.jscpd, targetPath, isTsProject),
+        deadCode: scanDeadCode(clients.knip, targetPath, isTsProject),
+        astIssues: scanAstGrep(targetPath, isTsProject, configPath),
+        biomeIssues: scanBiomeIssues(clients.biome, targetPath),
+        slopFiles: scanSlop(clients.complexity, targetPath, isTsProject),
+    };
+}

package/clients/fix-scanners.ts

@@ -0,0 +1,297 @@
+/**
+ * Scanner functions for fix.ts
+ *
+ * Each scanner encapsulates one type of issue detection:
+ * - scanDuplicates: JSCPD duplicate code detection
+ * - scanDeadCode: Knip dead code detection
+ * - scanAstGrep: Structural linting via ast-grep
+ * - scanBiome: Remaining Biome lint issues
+ * - scanSlop: AI slop indicators (high complexity patterns)
+ */
+
+import * as childProcess from "node:child_process";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import type { BiomeClient } from "./biome-client.js";
+import type { ComplexityClient } from "./complexity-client.js";
+import type { JscpdClient } from "./jscpd-client.js";
+import type { KnipClient } from "./knip-client.js";
+import { shouldIgnoreFile } from "./scan-utils.js";
+
+export interface DuplicateClone {
+	fileA: string;
+	fileB: string;
+	startA: number;
+	startB: number;
+	lines: number;
+}
+
+export interface DeadCodeIssue {
+	type: string;
+	name: string;
+	file?: string;
+}
+
+export interface AstIssue {
+	rule: string;
+	file: string;
+	line: number;
+	message: string;
+}
+
+export interface BiomeIssue {
+	file: string;
+	line: number;
+	rule: string;
+	message: string;
+}
+
+export interface SlopFile {
+	file: string;
+	warnings: string[];
+}
+
+export interface FixScanResults {
+	duplicates: DuplicateClone[];
+	deadCode: DeadCodeIssue[];
+	astIssues: AstIssue[];
+	biomeIssues: BiomeIssue[];
+	slopFiles: SlopFile[];
+}
+
+const DEBUG_LOG = path.join(
+	process.env.HOME || process.env.USERPROFILE || ".",
+	"pi-lens-debug.log",
+);
+
+function dbg(msg: string) {
+	const line = `[${new Date().toISOString()}] ${msg}\n`;
+	try {
+		nodeFs.appendFileSync(DEBUG_LOG, line);
+	} catch {
+		// Ignored
+	}
+}
+
+/**
+ * Scan for duplicate code blocks using JSCPD
+ */
+export function scanDuplicates(
+	jscpd: JscpdClient,
+	targetPath: string,
+	isTsProject: boolean,
+): DuplicateClone[] {
+	if (!jscpd.isAvailable()) return [];
+
+	const jscpdResult = jscpd.scan(targetPath);
+	return jscpdResult.clones.filter((c) => {
+		if (isTsProject && (c.fileA.endsWith(".js") || c.fileB.endsWith(".js")))
+			return false;
+		return path.resolve(c.fileA) !== path.resolve(c.fileB);
+	});
+}
+
+/**
+ * Scan for dead code using Knip
+ */
+export function scanDeadCode(
+	knip: KnipClient,
+	targetPath: string,
+	isTsProject: boolean,
+): DeadCodeIssue[] {
+	if (!knip.isAvailable()) return [];
+
+	const knipResult = knip.analyze(targetPath);
+	return knipResult.issues.filter((i) => {
+		if (!i.file) return true;
+		return !shouldIgnoreFile(i.file, isTsProject);
+	});
+}
+
+/**
+ * Scan for structural issues using ast-grep
+ */
+export function scanAstGrep(
+	targetPath: string,
+	isTsProject: boolean,
+	configPath: string,
+): AstIssue[] {
+	const hasSg = nodeFs.existsSync(path.join(targetPath, "node_modules", ".bin", "sg")) ||
+		childProcess.spawnSync("npx", ["sg", "--version"], { encoding: "utf-8", timeout: 5000, shell: true }).status === 0;
+
+	if (!hasSg) return [];
+
+	const result = childProcess.spawnSync(
+		"npx",
+		[
+			"sg",
+			"scan",
+			"--config",
+			configPath,
+			"--json",
+			"--globs",
+			"!**/*.test.ts",
+			"--globs",
+			"!**/*.spec.ts",
+			"--globs",
+			"!**/test-utils.ts",
+			"--globs",
+			"!**/.pi-lens/**",
+			...(isTsProject ? ["--globs", "!**/*.js"] : []),
+			targetPath,
+		],
+		{
+			encoding: "utf-8",
+			timeout: 30000,
+			shell: true,
+			maxBuffer: 32 * 1024 * 1024,
+		},
+	);
+
+	const raw = result.stdout?.trim() ?? "";
+	const items: any[] = raw.startsWith("[")
+		? (() => {
+				try {
+					return JSON.parse(raw);
+				} catch {
+					return [];
+				}
+			})()
+		: raw.split("\n").flatMap((l: string) => {
+				try {
+					return [JSON.parse(l)];
+				} catch {
+					return [];
+				}
+			});
+
+	const astIssues: AstIssue[] = [];
+	for (const item of items) {
+		const rule = item.ruleId || item.rule?.title || item.name || "unknown";
+		const line =
+			(item.labels?.[0]?.range?.start?.line ?? item.range?.start?.line ?? 0) +
+			1;
+		const relFile = path.relative(targetPath, item.file ?? "").replace(/\\/g, "/");
+
+		if (shouldIgnoreFile(relFile, isTsProject)) continue;
+
+		astIssues.push({
+			rule,
+			file: relFile,
+			line,
+			message: item.message ?? rule,
+		});
+	}
+
+	return astIssues;
+}
+
+/**
+ * Scan for remaining Biome lint issues (couldn't be auto-fixed)
+ */
+export function scanBiomeIssues(
+	biome: BiomeClient,
+	targetPath: string,
+): BiomeIssue[] {
+	if (!biome.isAvailable()) return [];
+
+	const checkResult = childProcess.spawnSync(
+		"npx",
+		["@biomejs/biome", "check", "--reporter=json", "--max-diagnostics=50", targetPath],
+		{ encoding: "utf-8", timeout: 20000, shell: true },
+	);
+
+	const remainingBiome: BiomeIssue[] = [];
+	try {
+		const data = JSON.parse(checkResult.stdout ?? "{}");
+		for (const diag of (data.diagnostics ?? []).slice(0, 20)) {
+			if (!diag.category?.startsWith("lint/")) continue;
+			const filePath = diag.location?.path?.file ?? "";
+			const line = diag.location?.span?.start?.line ?? 0;
+			const rule = diag.category ?? "lint";
+			remainingBiome.push({
+				file: path.relative(targetPath, filePath).replace(/\\/g, "/"),
+				line: line + 1,
+				rule,
+				message: diag.message ?? rule,
+			});
+		}
+	} catch (e) {
+		dbg(`biome lint parse failed: ${e}`);
+	}
+
+	return remainingBiome;
+}
+
+/**
+ * Scan for AI slop indicators (high complexity patterns)
+ */
+export function scanSlop(
+	complexity: ComplexityClient,
+	targetPath: string,
+	isTsProject: boolean,
+): SlopFile[] {
+	const slopFiles: SlopFile[] = [];
+
+	const scanDir = (dir: string) => {
+		if (!nodeFs.existsSync(dir)) return;
+		for (const entry of nodeFs.readdirSync(dir, { withFileTypes: true })) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (
+					["node_modules", ".git", "dist", "build", ".next", ".pi-lens"].includes(
+						entry.name,
+					)
+				)
+					continue;
+				scanDir(fullPath);
+			} else if (complexity.isSupportedFile(fullPath)) {
+				const metrics = complexity.analyzeFile(fullPath);
+				if (metrics) {
+					const warnings = complexity
+						.checkThresholds(metrics)
+						.filter(
+							(w) =>
+								w.includes("AI-style") ||
+								w.includes("try/catch") ||
+								w.includes("single-use") ||
+								w.includes("Excessive comments"),
+						);
+					const relFile = path
+						.relative(targetPath, fullPath)
+						.replace(/\\/g, "/");
+					if (shouldIgnoreFile(relFile, isTsProject)) continue;
+					if (warnings.length >= 2) {
+						slopFiles.push({ file: relFile, warnings });
+					}
+				}
+			}
+		}
+	};
+
+	scanDir(targetPath);
+	return slopFiles;
+}
+
+/**
+ * Run all scanners and return combined results
+ */
+export function scanAll(
+	clients: {
+		jscpd: JscpdClient;
+		knip: KnipClient;
+		biome: BiomeClient;
+		complexity: ComplexityClient;
+	},
+	targetPath: string,
+	isTsProject: boolean,
+	configPath: string,
+): FixScanResults {
+	return {
+		duplicates: scanDuplicates(clients.jscpd, targetPath, isTsProject),
+		deadCode: scanDeadCode(clients.knip, targetPath, isTsProject),
+		astIssues: scanAstGrep(targetPath, isTsProject, configPath),
+		biomeIssues: scanBiomeIssues(clients.biome, targetPath),
+		slopFiles: scanSlop(clients.complexity, targetPath, isTsProject),
+	};
+}