pi-lens 2.0.37 → 2.0.39

package/clients/scan-architectural-debt.ts

@@ -2,11 +2,14 @@
  * Shared architectural debt scanning — used by booboo-fix and booboo-refactor.
  * Scans ast-grep skip rules + complexity metrics + architect.yaml rules.
  */
+
+import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { ArchitectClient } from "./architect-client.js";
 import type { AstGrepClient } from "./ast-grep-client.js";
 import type { ComplexityClient } from "./complexity-client.js";
-import type { ArchitectClient } from "./architect-client.js";
+import { getSourceFiles, parseAstGrepJson } from "./scan-utils.js";
 
 export type SkipIssue = { rule: string; line: number; note: string };
 export type FileMetrics = { mi: number; cognitive: number; nesting: number };
@@ -25,29 +28,41 @@ export function scanSkipViolations(
 	const skipByFile = new Map<string, SkipIssue[]>();
 	if (!astGrepClient.isAvailable()) return skipByFile;
 
-	const { spawnSync } = require("node:child_process") as typeof import("node:child_process");
 	const sgResult = spawnSync(
 		"npx",
 		[
-			"sg", "scan", "--config", configPath, "--json",
-			"--globs", "!**/*.test.ts", "--globs", "!**/*.spec.ts",
-			"--globs", "!**/test-utils.ts", "--globs", "!**/.pi-lens/**",
+			"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 },
+		{
+			encoding: "utf-8",
+			timeout: 30000,
+			shell: true,
+			maxBuffer: 32 * 1024 * 1024,
+		},
 	);
 
-	const raw = sgResult.stdout?.trim() ?? "";
-	// biome-ignore lint/suspicious/noExplicitAny: ast-grep JSON output is untyped
-	const items: Record<string, any>[] = raw.startsWith("[")
-		? (() => { try { return JSON.parse(raw); } catch { return []; } })()
-		: raw.split("\n").flatMap((l: string) => { try { return [JSON.parse(l)]; } catch { return []; } });
+	const items = parseAstGrepJson(sgResult.stdout?.trim() ?? "");
 
 	for (const item of items) {
 		const rule = item.ruleId || item.rule?.title || item.name || "unknown";
 		if (!skipRules.has(rule)) continue;
-		const line = (item.labels?.[0]?.range?.start?.line ?? item.range?.start?.line ?? 0) + 1;
+		const line =
+			(item.labels?.[0]?.range?.start?.line ?? item.range?.start?.line ?? 0) +
+			1;
 		const absFile = path.resolve(item.file ?? "");
 		const list = skipByFile.get(absFile) ?? [];
 		list.push({ rule, line, note: ruleActions[rule]?.note ?? "" });
@@ -65,25 +80,22 @@ export function scanComplexityMetrics(
 	isTsProject: boolean,
 ): Map<string, FileMetrics> {
 	const metricsByFile = new Map<string, FileMetrics>();
+	const files = getSourceFiles(targetPath, isTsProject);
 
-	const scanDir = (dir: string) => {
-		if (!fs.existsSync(dir)) return;
-		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-			const full = path.join(dir, entry.name);
-			if (entry.isDirectory()) {
-				if (["node_modules", ".git", "dist", "build", ".next", ".pi-lens"].includes(entry.name)) continue;
-				scanDir(full);
-			} else if (
-				complexityClient.isSupportedFile(full) &&
-				!/\.(test|spec)\.[jt]sx?$/.test(entry.name) &&
-				!(isTsProject && /\.js$/.test(entry.name))
-			) {
-				const m = complexityClient.analyzeFile(full);
-				if (m) metricsByFile.set(full, { mi: m.maintainabilityIndex, cognitive: m.cognitiveComplexity, nesting: m.maxNestingDepth });
-			}
+	for (const full of files) {
+		if (
+			complexityClient.isSupportedFile(full) &&
+			!/\.(test|spec)\.[jt]sx?$/.test(path.basename(full))
+		) {
+			const m = complexityClient.analyzeFile(full);
+			if (m)
+				metricsByFile.set(full, {
+					mi: m.maintainabilityIndex,
+					cognitive: m.cognitiveComplexity,
+					nesting: m.maxNestingDepth,
+				});
 		}
-	};
-	scanDir(targetPath);
+	}
 	return metricsByFile;
 }
 
@@ -98,37 +110,31 @@ export function scanArchitectViolations(
 	const violationsByFile = new Map<string, string[]>();
 	if (!architectClient.hasConfig()) return violationsByFile;
 
-	const scanDir = (dir: string) => {
-		if (!fs.existsSync(dir)) return;
-		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-			const full = path.join(dir, entry.name);
-			if (entry.isDirectory()) {
-				if (["node_modules", ".git", "dist", "build", ".next", ".pi-lens"].includes(entry.name)) continue;
-				scanDir(full);
-			} else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
-				const relPath = path.relative(targetPath, full).replace(/\\/g, "/");
-				const content = fs.readFileSync(full, "utf-8");
-				const lineCount = content.split("\n").length;
-				const msgs: string[] = [];
-
-				// Check pattern violations
-				for (const v of architectClient.checkFile(relPath, content)) {
-					msgs.push(v.message);
-				}
-
-				// Check file size
-				const sizeV = architectClient.checkFileSize(relPath, lineCount);
-				if (sizeV) {
-					msgs.push(sizeV.message);
-				}
-
-				if (msgs.length > 0) {
-					violationsByFile.set(full, msgs);
-				}
-			}
+	const isTsProject = fs.existsSync(path.join(targetPath, "tsconfig.json"));
+	const files = getSourceFiles(targetPath, isTsProject);
+
+	for (const full of files) {
+		const relPath = path.relative(targetPath, full).replace(/\\/g, "/");
+		const content = fs.readFileSync(full, "utf-8");
+		const lineCount = content.split("\n").length;
+		const msgs: string[] = [];
+
+		// Check pattern violations
+		for (const v of architectClient.checkFile(relPath, content)) {
+			const lineStr = v.line ? `L${v.line}: ` : "";
+			msgs.push(`${lineStr}${v.message}`);
+		}
+
+		// Check file size
+		const sizeV = architectClient.checkFileSize(relPath, lineCount);
+		if (sizeV) {
+			msgs.push(sizeV.message);
 		}
-	};
-	scanDir(targetPath);
+
+		if (msgs.length > 0) {
+			violationsByFile.set(full, msgs);
+		}
+	}
 	return violationsByFile;
 }
 
@@ -150,9 +156,14 @@ export function scoreFiles(
 			let score = 0;
 			const m = metricsByFile.get(file);
 			if (m) {
-				if (m.mi < 20) score += 5; else if (m.mi < 40) score += 3; else if (m.mi < 60) score += 1;
-				if (m.cognitive > 300) score += 4; else if (m.cognitive > 150) score += 2; else if (m.cognitive > 80) score += 1;
-				if (m.nesting > 8) score += 2; else if (m.nesting > 5) score += 1;
+				if (m.mi < 20) score += 5;
+				else if (m.mi < 40) score += 3;
+				else if (m.mi < 60) score += 1;
+				if (m.cognitive > 300) score += 4;
+				else if (m.cognitive > 150) score += 2;
+				else if (m.cognitive > 80) score += 1;
+				if (m.nesting > 8) score += 2;
+				else if (m.nesting > 5) score += 1;
 			}
 			for (const issue of skipByFile.get(file) ?? []) {
 				if (issue.rule === "large-class") score += 5;
@@ -182,9 +193,13 @@ export function extractCodeSnippet(
 ): { snippet: string; start: number; end: number } | null {
 	try {
 		const fileLines = fs.readFileSync(filePath, "utf-8").split("\n");
-		const start = Math.max(0, (firstLine - 1) - contextLines);
+		const start = Math.max(0, firstLine - 1 - contextLines);
 		const end = Math.min(fileLines.length, start + maxLines);
-		return { snippet: fileLines.slice(start, end).join("\n"), start: start + 1, end };
+		return {
+			snippet: fileLines.slice(start, end).join("\n"),
+			start: start + 1,
+			end,
+		};
 	} catch {
 		return null;
 	}

package/clients/scan-utils.js

@@ -0,0 +1,98 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Common parsing logic for ast-grep JSON output (handles both array and NDJSON).
+ */
+// biome-ignore lint/suspicious/noExplicitAny: ast-grep JSON output is untyped
+export function parseAstGrepJson(raw) {
+    if (!raw)
+        return [];
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("[")) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return [];
+        }
+    }
+    return trimmed.split("\n").flatMap((l) => {
+        try {
+            return [JSON.parse(l)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+/**
+ * Check if a file should be ignored based on project type and common patterns.
+ */
+export function shouldIgnoreFile(filePath, isTsProject) {
+    const relPath = filePath.replace(/\\/g, "/");
+    const basename = path.basename(relPath);
+    // Ignore compiled JS in TS projects
+    const isJs = relPath.endsWith(".js") ||
+        relPath.endsWith(".mjs") ||
+        relPath.endsWith(".cjs");
+    if (isTsProject && isJs)
+        return true;
+    // Ignore test scripts and common test patterns
+    if (basename.startsWith("test-") ||
+        basename.includes(".test.") ||
+        basename.includes(".spec.")) {
+        return true;
+    }
+    // Ignore hidden directories and common build outputs
+    if (relPath.includes("/node_modules/") ||
+        relPath.includes("/.git/") ||
+        relPath.includes("/dist/") ||
+        relPath.includes("/build/") ||
+        relPath.includes("/.next/") ||
+        relPath.includes("/.pi-lens/")) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Recursively find source files in a directory, respecting common excludes.
+ */
+export function getSourceFiles(dir, isTsProject) {
+    const files = [];
+    if (!fs.existsSync(dir))
+        return files;
+    const scan = (d) => {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(d, entry.name);
+            if (entry.isDirectory()) {
+                if ([
+                    "node_modules",
+                    ".git",
+                    "dist",
+                    "build",
+                    ".next",
+                    ".pi-lens",
+                ].includes(entry.name))
+                    continue;
+                scan(full);
+            }
+            else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
+                // Skip compiled JS if it's a TS project
+                if (isTsProject &&
+                    entry.name.endsWith(".js") &&
+                    fs.existsSync(full.replace(/\.js$/, ".ts")))
+                    continue;
+                files.push(full);
+            }
+        }
+    };
+    scan(dir);
+    return files;
+}

package/clients/scan-utils.ts

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Common parsing logic for ast-grep JSON output (handles both array and NDJSON).
+ */
+// biome-ignore lint/suspicious/noExplicitAny: ast-grep JSON output is untyped
+export function parseAstGrepJson(raw: string): any[] {
+	if (!raw) return [];
+	const trimmed = raw.trim();
+	if (trimmed.startsWith("[")) {
+		try {
+			return JSON.parse(trimmed);
+		} catch {
+			return [];
+		}
+	}
+	return trimmed.split("\n").flatMap((l) => {
+		try {
+			return [JSON.parse(l)];
+		} catch {
+			return [];
+		}
+	});
+}
+
+/**
+ * Check if a file should be ignored based on project type and common patterns.
+ */
+export function shouldIgnoreFile(
+	filePath: string,
+	isTsProject: boolean,
+): boolean {
+	const relPath = filePath.replace(/\\/g, "/");
+	const basename = path.basename(relPath);
+
+	// Ignore compiled JS in TS projects
+	const isJs =
+		relPath.endsWith(".js") ||
+		relPath.endsWith(".mjs") ||
+		relPath.endsWith(".cjs");
+	if (isTsProject && isJs) return true;
+
+	// Ignore test scripts and common test patterns
+	if (
+		basename.startsWith("test-") ||
+		basename.includes(".test.") ||
+		basename.includes(".spec.")
+	) {
+		return true;
+	}
+
+	// Ignore hidden directories and common build outputs
+	if (
+		relPath.includes("/node_modules/") ||
+		relPath.includes("/.git/") ||
+		relPath.includes("/dist/") ||
+		relPath.includes("/build/") ||
+		relPath.includes("/.next/") ||
+		relPath.includes("/.pi-lens/")
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Recursively find source files in a directory, respecting common excludes.
+ */
+export function getSourceFiles(dir: string, isTsProject: boolean): string[] {
+	const files: string[] = [];
+	if (!fs.existsSync(dir)) return files;
+
+	const scan = (d: string) => {
+		let entries: fs.Dirent[] = [];
+		try {
+			entries = fs.readdirSync(d, { withFileTypes: true });
+		} catch {
+			return;
+		}
+
+		for (const entry of entries) {
+			const full = path.join(d, entry.name);
+			if (entry.isDirectory()) {
+				if (
+					[
+						"node_modules",
+						".git",
+						"dist",
+						"build",
+						".next",
+						".pi-lens",
+					].includes(entry.name)
+				)
+					continue;
+				scan(full);
+			} else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
+				// Skip compiled JS if it's a TS project
+				if (
+					isTsProject &&
+					entry.name.endsWith(".js") &&
+					fs.existsSync(full.replace(/\.js$/, ".ts"))
+				)
+					continue;
+				files.push(full);
+			}
+		}
+	};
+	scan(dir);
+	return files;
+}

package/clients/sg-runner.js

@@ -0,0 +1,138 @@
+/**
+ * SgRunner - encapsulates ast-grep subprocess management
+ *
+ * Extracted from AstGrepClient to simplify the main client.
+ * Handles: spawn, spawnSync, temp dir management, JSON parsing.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export class SgRunner {
+    constructor(verbose = false) {
+        this.log = verbose ? (msg) => console.error(`[sg-runner] ${msg}`) : () => { };
+    }
+    /**
+     * Check if ast-grep CLI is available
+     */
+    isAvailable() {
+        const result = spawnSync("npx", ["sg", "--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        return !result.error && result.status === 0;
+    }
+    /**
+     * Run ast-grep asynchronously, return parsed matches
+     */
+    async exec(args) {
+        return new Promise((resolve) => {
+            const proc = spawn("npx", ["sg", ...args], {
+                stdio: ["ignore", "pipe", "pipe"],
+                shell: true,
+            });
+            let stdout = "";
+            let stderr = "";
+            proc.stdout.on("data", (data) => (stdout += data.toString()));
+            proc.stderr.on("data", (data) => (stderr += data.toString()));
+            proc.on("error", (err) => {
+                if (err.message.includes("ENOENT")) {
+                    resolve({ matches: [], error: "ast-grep CLI not found. Install: npm i -D @ast-grep/cli" });
+                }
+                else {
+                    resolve({ matches: [], error: err.message });
+                }
+            });
+            proc.on("close", (code) => {
+                if (code !== 0 && !stdout.trim()) {
+                    resolve({
+                        matches: [],
+                        error: stderr.includes("No files found") ? undefined : stderr.trim() || `Exit code ${code}`,
+                    });
+                    return;
+                }
+                if (!stdout.trim()) {
+                    resolve({ matches: [] });
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(stdout);
+                    const matches = Array.isArray(parsed) ? parsed : [parsed];
+                    resolve({ matches });
+                }
+                catch {
+                    resolve({ matches: [], error: "Failed to parse output" });
+                }
+            });
+        });
+    }
+    /**
+     * Run ast-grep synchronously (for simple scans)
+     */
+    execSync(args) {
+        const result = spawnSync("npx", ["sg", ...args], {
+            encoding: "utf-8",
+            timeout: 30000,
+            shell: true,
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        if (result.error) {
+            return { output: "", error: result.error.message };
+        }
+        const output = result.stdout || result.stderr || "";
+        return { output };
+    }
+    /**
+     * Run a temporary rule scan (creates temp dir with rule file)
+     */
+    tempScan(dir, ruleId, ruleYaml, timeout = 30000) {
+        const tmpDir = os.tmpdir();
+        const ts = Date.now();
+        const sessionDir = path.join(tmpDir, `pi-lens-temp-${ruleId}-${ts}`);
+        const rulesSubdir = path.join(sessionDir, "rules");
+        const ruleFile = path.join(rulesSubdir, `${ruleId}.yml`);
+        const configFile = path.join(sessionDir, ".sgconfig.yml");
+        try {
+            fs.mkdirSync(rulesSubdir, { recursive: true });
+            fs.writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
+            fs.writeFileSync(ruleFile, ruleYaml);
+            const result = spawnSync("npx", ["sg", "scan", "--config", configFile, "--json", dir], { encoding: "utf-8", timeout, shell: true });
+            const output = result.stdout || result.stderr || "";
+            if (!output.trim())
+                return [];
+            const items = JSON.parse(output);
+            return Array.isArray(items) ? items : [items];
+        }
+        catch {
+            return [];
+        }
+        finally {
+            try {
+                fs.rmSync(sessionDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                this.log(`Cleanup failed: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * Format matches for display
+     */
+    formatMatches(matches, isDryRun = false, maxItems = 50) {
+        if (matches.length === 0)
+            return "No matches found";
+        const shown = matches.slice(0, maxItems);
+        const lines = shown.map((m) => {
+            const loc = `${m.file}:${m.range.start.line + 1}:${m.range.start.column + 1}`;
+            const text = m.text.length > 100 ? `${m.text.slice(0, 100)}...` : m.text;
+            return isDryRun && m.replacement
+                ? `${loc}\n  - ${text}\n  + ${m.replacement}`
+                : `${loc}: ${text}`;
+        });
+        if (matches.length > maxItems) {
+            lines.unshift(`Found ${matches.length} matches (showing first ${maxItems}):`);
+        }
+        return lines.join("\n");
+    }
+}