pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/ast-grep.ts

@@ -9,6 +9,8 @@
 
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawn } from "../../safe-spawn.js";
 import type {
 	Diagnostic,
 	DispatchContext,
@@ -16,6 +18,27 @@ import type {
 	RunnerResult,
 } from "../types.js";
 
+// Simple YAML fix: field extractor
+function extractFixFromRule(ruleId: string, ruleDir: string): string | undefined {
+	try {
+		const rulePath = `${ruleDir}/${ruleId}.yml`;
+		if (!fs.existsSync(rulePath)) return undefined;
+		
+		const content = fs.readFileSync(rulePath, "utf-8");
+		const fixMatch = content.match(/^fix:\s*\|?([\s\S]*?)(?=^\w|^rule:|\Z)/m);
+		if (fixMatch) {
+			return fixMatch[1]
+				.split("\n")
+				.map((line) => line.replace(/^\s*\|?\s*/, ""))
+				.filter((line) => line.length > 0)
+				.join("\n");
+		}
+	} catch {
+		// Ignore errors
+	}
+	return undefined;
+}
+
 const astGrepRunner: RunnerDefinition = {
 	id: "ast-grep",
 	appliesTo: ["jsts", "python", "go", "rust", "cxx"],
@@ -24,11 +47,9 @@ const astGrepRunner: RunnerDefinition = {
 	skipTestFiles: true, // Many rules are noisy in tests
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
-		// Check if ast-grep is available
-		const check = spawnSync("sg", ["--version"], {
-			encoding: "utf-8",
+		// Check if ast-grep is available (use npx for local installs)
+		const check = safeSpawn("npx", ["sg", "--version"], {
 			timeout: 5000,
-			shell: true,
 		});
 
 		if (check.error || check.status !== 0) {
@@ -41,13 +62,11 @@ const astGrepRunner: RunnerDefinition = {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
-		// Run ast-grep scan on the file
-		const args = ["scan", "--config", configPath, "--json", ctx.filePath];
+		// Run ast-grep scan on the file (use npx for local installs)
+		const args = ["sg", "scan", "--config", configPath, "--json", ctx.filePath];
 
-		const result = spawnSync("sg", args, {
-			encoding: "utf-8",
+		const result = safeSpawn("npx", args, {
 			timeout: 30000,
-			shell: true,
 		});
 
 		const raw = result.stdout + result.stderr;
@@ -57,7 +76,7 @@ const astGrepRunner: RunnerDefinition = {
 		}
 
 		// Parse results
-		const diagnostics = parseAstGrepOutput(raw, ctx.filePath);
+		const diagnostics = parseAstGrepOutput(raw, ctx.filePath, configPath);
 
 		if (diagnostics.length === 0) {
 			return { status: "succeeded", diagnostics: [], semantic: "none" };
@@ -88,28 +107,61 @@ function findAstGrepConfig(cwd: string): string | undefined {
 	return undefined;
 }
 
-function parseAstGrepOutput(raw: string, filePath: string): Diagnostic[] {
+function parseAstGrepOutput(
+	raw: string,
+	filePath: string,
+	_configPath?: string,
+): Diagnostic[] {
 	const diagnostics: Diagnostic[] = [];
 
 	// Try to parse as JSON
+	// Determine rule directory for fix: extraction
+	const ruleDir = _configPath
+		? path.dirname(_configPath).replace("/.sgconfig.yml", "/rules")
+		: path.join(process.cwd(), "rules", "ast-grep-rules", "rules");
+	
 	try {
 		const parsed = JSON.parse(raw);
 		if (Array.isArray(parsed)) {
 			for (const item of parsed) {
 				const line = item.range?.start?.line || 1;
+				const ruleId = item.rule || "unknown";
+				
+				// Build message with inline fix suggestion
+				let message = item.message || item.lines || "";
+				let fixSuggestion: string | undefined;
+
+				if (item.replacement) {
+					// Show the actual code change inline in the message
+					const replacementPreview =
+						item.replacement.length > 40
+							? `${item.replacement.substring(0, 40)}...`
+							: item.replacement;
+					message += `\n💡 Suggested fix: → "${replacementPreview}"`;
+					fixSuggestion = `Replace with: ${item.replacement}`;
+				} else {
+					// Try to get fix: from rule YAML
+					const ruleFix = extractFixFromRule(ruleId, ruleDir);
+					if (ruleFix) {
+						const fixPreview = ruleFix.length > 60
+							? `${ruleFix.substring(0, 60)}...`
+							: ruleFix;
+						message += `\n💡 Suggested fix:\n${fixPreview}`;
+						fixSuggestion = ruleFix;
+					}
+				}
+
 				diagnostics.push({
-					id: `ast-grep-${line}-${item.rule || "unknown"}`,
-					message: item.message || item.lines || "",
+					id: `ast-grep-${line}-${ruleId}`,
+					message,
 					filePath,
 					line,
 					severity: item.severity === "error" ? "error" : "warning",
 					semantic: item.severity === "error" ? "blocking" : "warning",
 					tool: "ast-grep",
-					rule: item.rule || "unknown",
-					fixable: !!item.replacement,
-					fixSuggestion: item.replacement
-						? "Run `sg fix` to auto-fix"
-						: undefined,
+					rule: ruleId,
+					fixable: !!item.replacement || !!fixSuggestion,
+					fixSuggestion,
 				});
 			}
 		}

package/clients/dispatch/runners/biome.js

@@ -3,46 +3,49 @@
  *
  * Requires: @biomejs/biome (npm install -D @biomejs/biome)
  */
-import { spawnSync } from "node:child_process";
-// Cache biome availability check
-let biomeAvailable = null;
-function isBiomeAvailable() {
-    if (biomeAvailable !== null)
-        return biomeAvailable;
-    // Check if biome CLI is available (do NOT auto-install via npx)
-    const check = spawnSync("biome", ["--version"], {
-        encoding: "utf-8",
-        timeout: 5000,
-        shell: true,
-    });
-    biomeAvailable = !check.error && check.status === 0;
-    return biomeAvailable;
-}
+import { safeSpawn } from "../../safe-spawn.js";
+import { createBiomeParser } from "./utils/diagnostic-parsers.js";
+import { biome } from "./utils/runner-helpers.js";
 const biomeRunner = {
     id: "biome-lint",
     appliesTo: ["jsts", "json"],
     priority: 10,
     enabledByDefault: true,
     async run(ctx) {
-        // Skip if biome is not installed
-        if (!isBiomeAvailable()) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
+        // Check if biome is available (via PATH, venv, or npx)
+        let cmd = biome.getCommand();
+        let useNpx = false;
+        if (!cmd || !biome.isAvailable(ctx.cwd)) {
+            // Try npx as fallback
+            const npxCheck = safeSpawn("npx", ["biome", "--version"], {
+                timeout: 5000,
+            });
+            if (!npxCheck.error && npxCheck.status === 0) {
+                cmd = "npx";
+                useNpx = true;
+            }
+            else {
+                return { status: "skipped", diagnostics: [], semantic: "none" };
+            }
         }
-        // Run biome check (use direct command, not npx)
-        const args = ctx.autofix
-            ? ["check", "--write", ctx.filePath]
+        // IMPORTANT: Never use --write in dispatch runner to prevent infinite loops.
+        // Writing to the file would trigger another tool_result event, which would
+        // call dispatchLint again, creating a feedback loop.
+        // Use /lens-format command for explicit formatting, or autofix flags on
+        // the write/edit tools directly.
+        const args = useNpx
+            ? ["biome", "check", ctx.filePath]
             : ["check", ctx.filePath];
-        const result = spawnSync("biome", args, {
-            encoding: "utf-8",
+        const result = safeSpawn(cmd, args, {
             timeout: 30000,
-            shell: true,
         });
         const output = result.stdout + result.stderr;
         if (result.status === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
-        // Parse diagnostics
-        const diagnostics = parseBiomeOutput(output, ctx.filePath, ctx.autofix);
+        // Parse diagnostics (never autofix in dispatch to prevent loops)
+        const parseBiomeOutput = createBiomeParser(false);
+        const diagnostics = parseBiomeOutput(output, ctx.filePath);
         return {
             status: "failed",
             diagnostics,
@@ -50,31 +53,4 @@ const biomeRunner = {
         };
     },
 };
-function parseBiomeOutput(raw, filePath, autofix) {
-    const clean = raw.replace(/\x1b\[[0-9;]*m/g, "");
-    const lines = clean.split("\n").filter((l) => l.trim());
-    const diagnostics = [];
-    for (const line of lines) {
-        // Parse biome output format: file:line:col message (category)
-        const match = line.match(/^(.+?):(\d+):(\d+)\s+(.+?)\s*\((.+?)\)/);
-        if (match) {
-            diagnostics.push({
-                id: `biome-${match[2]}-${match[5]}`,
-                message: `${match[5]}: ${match[4]}`,
-                filePath,
-                line: parseInt(match[2], 10),
-                column: parseInt(match[3], 10),
-                severity: line.includes("error") ? "error" : "warning",
-                semantic: "warning",
-                tool: "biome",
-                rule: match[5],
-                fixable: true,
-                fixSuggestion: autofix
-                    ? "Auto-fix applied"
-                    : "Run with --autofix-biome to fix",
-            });
-        }
-    }
-    return diagnostics;
-}
 export default biomeRunner;

package/clients/dispatch/runners/biome.ts

@@ -4,29 +4,14 @@
  * Requires: @biomejs/biome (npm install -D @biomejs/biome)
  */
 
-import { spawnSync } from "node:child_process";
+import { safeSpawn } from "../../safe-spawn.js";
 import type {
-	Diagnostic,
 	DispatchContext,
 	RunnerDefinition,
 	RunnerResult,
 } from "../types.js";
-
-// Cache biome availability check
-let biomeAvailable: boolean | null = null;
-
-function isBiomeAvailable(): boolean {
-	if (biomeAvailable !== null) return biomeAvailable;
-
-	// Check if biome CLI is available (do NOT auto-install via npx)
-	const check = spawnSync("biome", ["--version"], {
-		encoding: "utf-8",
-		timeout: 5000,
-		shell: true,
-	});
-	biomeAvailable = !check.error && check.status === 0;
-	return biomeAvailable;
-}
+import { createBiomeParser } from "./utils/diagnostic-parsers.js";
+import { biome } from "./utils/runner-helpers.js";
 
 const biomeRunner: RunnerDefinition = {
 	id: "biome-lint",
@@ -35,20 +20,34 @@ const biomeRunner: RunnerDefinition = {
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
-		// Skip if biome is not installed
-		if (!isBiomeAvailable()) {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
+		// Check if biome is available (via PATH, venv, or npx)
+		let cmd = biome.getCommand();
+		let useNpx = false;
+
+		if (!cmd || !biome.isAvailable(ctx.cwd)) {
+			// Try npx as fallback
+			const npxCheck = safeSpawn("npx", ["biome", "--version"], {
+				timeout: 5000,
+			});
+			if (!npxCheck.error && npxCheck.status === 0) {
+				cmd = "npx";
+				useNpx = true;
+			} else {
+				return { status: "skipped", diagnostics: [], semantic: "none" };
+			}
 		}
 
-		// Run biome check (use direct command, not npx)
-		const args = ctx.autofix
-			? ["check", "--write", ctx.filePath]
+		// IMPORTANT: Never use --write in dispatch runner to prevent infinite loops.
+		// Writing to the file would trigger another tool_result event, which would
+		// call dispatchLint again, creating a feedback loop.
+		// Use /lens-format command for explicit formatting, or autofix flags on
+		// the write/edit tools directly.
+		const args = useNpx
+			? ["biome", "check", ctx.filePath]
 			: ["check", ctx.filePath];
 
-		const result = spawnSync("biome", args, {
-			encoding: "utf-8",
+		const result = safeSpawn(cmd, args, {
 			timeout: 30000,
-			shell: true,
 		});
 
 		const output = result.stdout + result.stderr;
@@ -57,8 +56,9 @@ const biomeRunner: RunnerDefinition = {
 			return { status: "succeeded", diagnostics: [], semantic: "none" };
 		}
 
-		// Parse diagnostics
-		const diagnostics = parseBiomeOutput(output, ctx.filePath, ctx.autofix);
+		// Parse diagnostics (never autofix in dispatch to prevent loops)
+		const parseBiomeOutput = createBiomeParser(false);
+		const diagnostics = parseBiomeOutput(output, ctx.filePath);
 
 		return {
 			status: "failed",
@@ -68,38 +68,4 @@ const biomeRunner: RunnerDefinition = {
 	},
 };
 
-function parseBiomeOutput(
-	raw: string,
-	filePath: string,
-	autofix: boolean,
-): Diagnostic[] {
-	const clean = raw.replace(/\x1b\[[0-9;]*m/g, "");
-	const lines = clean.split("\n").filter((l) => l.trim());
-	const diagnostics: Diagnostic[] = [];
-
-	for (const line of lines) {
-		// Parse biome output format: file:line:col message (category)
-		const match = line.match(/^(.+?):(\d+):(\d+)\s+(.+?)\s*\((.+?)\)/);
-		if (match) {
-			diagnostics.push({
-				id: `biome-${match[2]}-${match[5]}`,
-				message: `${match[5]}: ${match[4]}`,
-				filePath,
-				line: parseInt(match[2], 10),
-				column: parseInt(match[3], 10),
-				severity: line.includes("error") ? "error" : "warning",
-				semantic: "warning",
-				tool: "biome",
-				rule: match[5],
-				fixable: true,
-				fixSuggestion: autofix
-					? "Auto-fix applied"
-					: "Run with --autofix-biome to fix",
-			});
-		}
-	}
-
-	return diagnostics;
-}
-
 export default biomeRunner;

package/clients/dispatch/runners/config-validation.js

@@ -0,0 +1,67 @@
+/**
+ * Config Validation Runner
+ *
+ * Validates config/environment variable access against actual config files.
+ * Detects undefined keys, typos, and missing env vars.
+ *
+ * Uses Tree-sitter to find config access patterns in code and validates
+ * against parsed config files (.env, config.ini, config.yaml, etc.)
+ */
+import { createConfigValidator } from "../../config-validator.js";
+const configValidationRunner = {
+    id: "config-validation",
+    appliesTo: ["jsts", "python", "go", "rust"],
+    priority: 8, // Run early, before other linters
+    enabledByDefault: true,
+    async run(ctx) {
+        // Only check supported file extensions
+        const ext = ctx.filePath.match(/\.(py|js|ts|tsx|go|rs)$/);
+        if (!ext) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        try {
+            const validator = await createConfigValidator(ctx.cwd);
+            const result = await validator.validateFile(ctx.filePath);
+            const diagnostics = [];
+            // Report undefined keys as warnings
+            for (const access of result.undefined) {
+                diagnostics.push({
+                    id: `config-undefined:${access.key}`,
+                    message: `Undefined config key: "${access.key}"`,
+                    filePath: ctx.filePath,
+                    line: access.line,
+                    column: access.column,
+                    severity: "warning",
+                    semantic: "warning",
+                    tool: "config-validation",
+                });
+            }
+            // Report typos with suggestion
+            for (const { access, suggestion } of result.typos) {
+                diagnostics.push({
+                    id: `config-typo:${access.key}`,
+                    message: `Possible typo: "${access.key}" — did you mean "${suggestion}"?`,
+                    filePath: ctx.filePath,
+                    line: access.line,
+                    column: access.column,
+                    severity: "warning",
+                    semantic: "warning",
+                    tool: "config-validation",
+                });
+            }
+            if (diagnostics.length === 0) {
+                return { status: "succeeded", diagnostics: [], semantic: "none" };
+            }
+            return {
+                status: "failed",
+                diagnostics,
+                semantic: "warning",
+            };
+        }
+        catch (_err) {
+            // Silently fail if validator can't run (e.g., tree-sitter not available)
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+    },
+};
+export default configValidationRunner;

package/clients/dispatch/runners/config-validation.ts

@@ -0,0 +1,82 @@
+/**
+ * Config Validation Runner
+ *
+ * Validates config/environment variable access against actual config files.
+ * Detects undefined keys, typos, and missing env vars.
+ *
+ * Uses Tree-sitter to find config access patterns in code and validates
+ * against parsed config files (.env, config.ini, config.yaml, etc.)
+ */
+
+import { createConfigValidator } from "../../config-validator.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const configValidationRunner: RunnerDefinition = {
+	id: "config-validation",
+	appliesTo: ["jsts", "python", "go", "rust"],
+	priority: 8, // Run early, before other linters
+	enabledByDefault: true,
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		// Only check supported file extensions
+		const ext = ctx.filePath.match(/\.(py|js|ts|tsx|go|rs)$/);
+		if (!ext) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		try {
+			const validator = await createConfigValidator(ctx.cwd);
+			const result = await validator.validateFile(ctx.filePath);
+
+			const diagnostics: Diagnostic[] = [];
+
+			// Report undefined keys as warnings
+			for (const access of result.undefined) {
+				diagnostics.push({
+					id: `config-undefined:${access.key}`,
+					message: `Undefined config key: "${access.key}"`,
+					filePath: ctx.filePath,
+					line: access.line,
+					column: access.column,
+					severity: "warning",
+					semantic: "warning",
+					tool: "config-validation",
+				});
+			}
+
+			// Report typos with suggestion
+			for (const { access, suggestion } of result.typos) {
+				diagnostics.push({
+					id: `config-typo:${access.key}`,
+					message: `Possible typo: "${access.key}" — did you mean "${suggestion}"?`,
+					filePath: ctx.filePath,
+					line: access.line,
+					column: access.column,
+					severity: "warning",
+					semantic: "warning",
+					tool: "config-validation",
+				});
+			}
+
+			if (diagnostics.length === 0) {
+				return { status: "succeeded", diagnostics: [], semantic: "none" };
+			}
+
+			return {
+				status: "failed",
+				diagnostics,
+				semantic: "warning",
+			};
+		} catch (_err) {
+			// Silently fail if validator can't run (e.g., tree-sitter not available)
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+	},
+};
+
+export default configValidationRunner;

package/clients/dispatch/runners/go-vet.js

@@ -3,8 +3,9 @@
  *
  * Runs `go vet` for Go files to catch common mistakes.
  */
-import { spawnSync } from "node:child_process";
+import { safeSpawn } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
+import { parseGoVetOutput } from "./utils/diagnostic-parsers.js";
 const goVetRunner = {
     id: "go-vet",
     appliesTo: ["go"],
@@ -12,19 +13,15 @@ const goVetRunner = {
     enabledByDefault: true,
     async run(ctx) {
         // Check if go is available
-        const check = spawnSync("go", ["version"], {
-            encoding: "utf-8",
+        const check = safeSpawn("go", ["version"], {
             timeout: 5000,
-            shell: true,
         });
         if (check.error || check.status !== 0) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         // Run go vet on the file
-        const result = spawnSync("go", ["vet", ctx.filePath], {
-            encoding: "utf-8",
+        const result = safeSpawn("go", ["vet", ctx.filePath], {
             timeout: 30000,
-            shell: true,
         });
         const raw = stripAnsi(result.stdout + result.stderr);
         if (result.status === 0 && !raw.trim()) {
@@ -48,25 +45,4 @@ const goVetRunner = {
         };
     },
 };
-function parseGoVetOutput(raw, filePath) {
-    const diagnostics = [];
-    const lines = raw.split("\n");
-    for (const line of lines) {
-        // Parse go vet output: file:line:col: message
-        const match = line.match(/^(.+?):(\d+):(\d+):\s*(.+)/);
-        if (match) {
-            diagnostics.push({
-                id: `go-vet-${match[2]}`,
-                message: match[4],
-                filePath,
-                line: parseInt(match[2], 10),
-                column: parseInt(match[3], 10),
-                severity: "warning",
-                semantic: "warning",
-                tool: "go-vet",
-            });
-        }
-    }
-    return diagnostics;
-}
 export default goVetRunner;

package/clients/dispatch/runners/go-vet.ts

@@ -4,10 +4,10 @@
  * Runs `go vet` for Go files to catch common mistakes.
  */
 
-import { spawnSync } from "node:child_process";
+import { safeSpawn } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
+import { parseGoVetOutput } from "./utils/diagnostic-parsers.js";
 import type {
-	Diagnostic,
 	DispatchContext,
 	RunnerDefinition,
 	RunnerResult,
@@ -21,10 +21,8 @@ const goVetRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		// Check if go is available
-		const check = spawnSync("go", ["version"], {
-			encoding: "utf-8",
+		const check = safeSpawn("go", ["version"], {
 			timeout: 5000,
-			shell: true,
 		});
 
 		if (check.error || check.status !== 0) {
@@ -32,10 +30,8 @@ const goVetRunner: RunnerDefinition = {
 		}
 
 		// Run go vet on the file
-		const result = spawnSync("go", ["vet", ctx.filePath], {
-			encoding: "utf-8",
+		const result = safeSpawn("go", ["vet", ctx.filePath], {
 			timeout: 30000,
-			shell: true,
 		});
 
 		const raw = stripAnsi(result.stdout + result.stderr);
@@ -65,28 +61,4 @@ const goVetRunner: RunnerDefinition = {
 	},
 };
 
-function parseGoVetOutput(raw: string, filePath: string): Diagnostic[] {
-	const diagnostics: Diagnostic[] = [];
-	const lines = raw.split("\n");
-
-	for (const line of lines) {
-		// Parse go vet output: file:line:col: message
-		const match = line.match(/^(.+?):(\d+):(\d+):\s*(.+)/);
-		if (match) {
-			diagnostics.push({
-				id: `go-vet-${match[2]}`,
-				message: match[4],
-				filePath,
-				line: parseInt(match[2], 10),
-				column: parseInt(match[3], 10),
-				severity: "warning",
-				semantic: "warning",
-				tool: "go-vet",
-			});
-		}
-	}
-
-	return diagnostics;
-}
-
 export default goVetRunner;