pi-lens 2.2.9 → 3.0.0

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

@@ -0,0 +1,506 @@
+/**
+ * ast-grep NAPI runner for dispatch system
+ *
+ * Uses @ast-grep/napi for programmatic parsing instead of CLI.
+ * Handles TypeScript/JavaScript/CSS/HTML files with YAML rule support.
+ * 
+ * Replaces CLI-based runners for faster performance (100x speedup).
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Lazy load the napi package
+let sg: typeof import("@ast-grep/napi") | undefined;
+
+async function loadSg(): Promise<typeof import("@ast-grep/napi") | undefined> {
+	if (sg) return sg;
+	try {
+		sg = await import("@ast-grep/napi");
+		return sg;
+	} catch {
+		return undefined;
+	}
+}
+
+// Supported extensions for NAPI
+const SUPPORTED_EXTS = [".ts", ".tsx", ".js", ".jsx", ".css", ".html", ".htm"];
+
+function canHandle(filePath: string): boolean {
+	return SUPPORTED_EXTS.includes(path.extname(filePath).toLowerCase());
+}
+
+function getLang(filePath: string, sgModule: typeof import("@ast-grep/napi")): any {
+	const ext = path.extname(filePath).toLowerCase();
+	switch (ext) {
+		case ".ts": return sgModule.Lang.TypeScript;
+		case ".tsx": return sgModule.Lang.Tsx;
+		case ".js":
+		case ".jsx": return sgModule.Lang.JavaScript;
+		case ".css": return sgModule.Lang.Css;
+		case ".html":
+		case ".htm": return sgModule.Lang.Html;
+		default: return undefined;
+	}
+}
+
+// YAML rule types
+interface YamlRuleCondition {
+	kind?: string;
+	pattern?: string;
+	regex?: string;
+	has?: YamlRuleCondition;
+	any?: YamlRuleCondition[];
+	all?: YamlRuleCondition[];
+	not?: YamlRuleCondition;
+}
+
+interface YamlRule {
+	id: string;
+	language?: string;
+	severity?: string;
+	message?: string;
+	metadata?: { weight?: number; category?: string };
+	rule?: YamlRuleCondition;
+}
+
+function loadYamlRules(ruleDir: string): YamlRule[] {
+	const rules: YamlRule[] = [];
+	if (!fs.existsSync(ruleDir)) return rules;
+	
+	const files = fs.readdirSync(ruleDir).filter(f => f.endsWith(".yml"));
+	
+	for (const file of files) {
+		try {
+			const content = fs.readFileSync(path.join(ruleDir, file), "utf-8");
+			// Split by --- to handle multiple YAML documents in one file
+			const documents = content.split(/^---$/m).filter(d => d.trim());
+			
+			for (const doc of documents) {
+				const rule = parseSimpleYaml(doc.trim());
+				if (rule && rule.id) {
+					rules.push(rule);
+				}
+			}
+		} catch {
+			// Skip invalid files
+		}
+	}
+	
+	return rules;
+}
+
+function parseSimpleYaml(content: string): YamlRule | null {
+	const lines = content.split("\n");
+	const rule: YamlRule = { id: "", metadata: {} };
+	let currentSection: "root" | "rule" | "metadata" = "root";
+	let sectionStack: Array<{ name: string; indent: number; obj: any }> = [];
+	let multilineBuffer: string[] = [];
+	let multilineKey = "";
+	
+	function getCurrentObj(): any {
+		if (sectionStack.length === 0) return rule;
+		return sectionStack[sectionStack.length - 1].obj;
+	}
+	
+	function getIndent(line: string): number {
+		let count = 0;
+		for (const char of line) {
+			if (char === " ") count++;
+			else if (char === "\t") count += 2;
+			else break;
+		}
+		return count;
+	}
+	
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		
+		if (trimmed === "---") continue;
+		
+		const indent = getIndent(line);
+		
+		// Pop stack if indent decreased
+		while (sectionStack.length > 0 && indent <= sectionStack[sectionStack.length - 1].indent) {
+			sectionStack.pop();
+		}
+		
+		// Check for multiline continuation
+		if (line.startsWith(" ") && !trimmed.includes(":") && multilineKey) {
+			multilineBuffer.push(trimmed);
+			continue;
+		}
+		
+		// Flush multiline buffer
+		if (multilineKey && multilineBuffer.length > 0) {
+			const value = multilineBuffer.join("\n");
+			const current = getCurrentObj();
+			if (multilineKey === "pattern" && current) {
+				current.pattern = value;
+			}
+			multilineKey = "";
+			multilineBuffer = [];
+		}
+		
+		const colonIndex = trimmed.indexOf(":");
+		const key = colonIndex > 0 ? trimmed.substring(0, colonIndex).trim() : trimmed;
+		const value = colonIndex > 0 ? trimmed.substring(colonIndex + 1).trim() : "";
+		
+		if (key === "id") {
+			rule.id = value.replace(/^["']|["']$/g, "");
+		} else if (key === "language") {
+			rule.language = value;
+		} else if (key === "severity") {
+			rule.severity = value;
+		} else if (key === "message") {
+			if (value === "|") {
+				multilineKey = "message";
+			} else {
+				rule.message = value.replace(/^["']|["']$/g, "");
+			}
+		} else if (key === "metadata") {
+			currentSection = "metadata";
+			const newObj = {};
+			rule.metadata = newObj;
+			sectionStack.push({ name: "metadata", indent, obj: newObj });
+		} else if (key === "rule") {
+			currentSection = "rule";
+			const newObj: YamlRuleCondition = {};
+			rule.rule = newObj;
+			sectionStack.push({ name: "rule", indent, obj: newObj });
+		} else if (sectionStack.length > 0) {
+			const current = getCurrentObj();
+			const currentSectionName = sectionStack[sectionStack.length - 1]?.name;
+			
+			if (key === "weight" && currentSectionName === "metadata") {
+				if (!rule.metadata) rule.metadata = {};
+				rule.metadata.weight = parseInt(value, 10) || 3;
+			} else if (key === "category" && currentSectionName === "metadata") {
+				if (!rule.metadata) rule.metadata = {};
+				rule.metadata.category = value.replace(/^["']|["']$/g, "");
+			} else if (key === "pattern") {
+				if (value === "|") {
+					multilineKey = "pattern";
+				} else {
+					// Strip all surrounding quotes (handle nested quotes from YAML)
+					let stripped = value;
+					while (stripped.startsWith('"') && stripped.endsWith('"') && stripped.length > 1) {
+						stripped = stripped.slice(1, -1);
+					}
+					while (stripped.startsWith("'") && stripped.endsWith("'") && stripped.length > 1) {
+						stripped = stripped.slice(1, -1);
+					}
+					current.pattern = stripped;
+				}
+			} else if (key === "kind") {
+				current.kind = value;
+			} else if (key === "regex") {
+				// Strip all surrounding quotes
+				let stripped = value;
+				while (stripped.startsWith('"') && stripped.endsWith('"') && stripped.length > 1) {
+					stripped = stripped.slice(1, -1);
+				}
+				while (stripped.startsWith("'") && stripped.endsWith("'") && stripped.length > 1) {
+					stripped = stripped.slice(1, -1);
+				}
+				current.regex = stripped;
+			} else if (key === "has" || key === "not") {
+				const newObj: YamlRuleCondition = {};
+				current[key] = newObj;
+				sectionStack.push({ name: key, indent, obj: newObj });
+			} else if (key === "any" || key === "all") {
+				if (!current[key]) current[key] = [];
+				// Check if next lines with more indent are list items
+				let j = i + 1;
+				while (j < lines.length) {
+					const nextLine = lines[j];
+					const nextTrimmed = nextLine.trim();
+					if (!nextTrimmed || nextTrimmed.startsWith("#")) {
+						j++;
+						continue;
+					}
+					const nextIndent = getIndent(nextLine);
+					if (nextIndent <= indent) break;
+					
+					if (nextTrimmed.startsWith("- ")) {
+						// New list item
+						const itemObj: YamlRuleCondition = {};
+						current[key].push(itemObj);
+						sectionStack.push({ name: key, indent: nextIndent, obj: itemObj });
+						// Parse the item content after "- "
+						const itemContent = nextTrimmed.substring(2);
+						if (itemContent.includes(":")) {
+							const [itemKey, itemVal] = itemContent.split(":", 2);
+							if (itemKey.trim() === "pattern") {
+								itemObj.pattern = itemVal.trim().replace(/^["']|["']$/g, "");
+							} else if (itemKey.trim() === "kind") {
+								itemObj.kind = itemVal.trim();
+							}
+						} else if (itemContent) {
+							// Assume it's a pattern
+							itemObj.pattern = itemContent.replace(/^["']|["']$/g, "");
+						}
+					}
+					j++;
+				}
+			}
+		}
+	}
+	
+	// Flush remaining multiline buffer
+	if (multilineKey && multilineBuffer.length > 0) {
+		const value = multilineBuffer.join("\n");
+		const current = getCurrentObj();
+		if (multilineKey === "pattern" && current) {
+			current.pattern = value;
+		} else if (multilineKey === "message") {
+			rule.message = value;
+		}
+	}
+	
+	return rule.id ? rule : null;
+}
+
+/**
+ * Check if a rule uses structured conditions (has/any/all/not/regex)
+ */
+function isStructuredRule(rule: YamlRule): boolean {
+	if (!rule.rule) return false;
+	return !!(rule.rule.has || rule.rule.any || rule.rule.all || rule.rule.not || rule.rule.regex);
+}
+
+/**
+ * Execute a structured rule using manual AST traversal
+ */
+function executeStructuredRule(
+	rootNode: any,
+	condition: YamlRuleCondition,
+	matches: any[] = []
+): any[] {
+	// Start with finding nodes by kind or pattern
+	let candidates: any[] = [];
+	
+	if (condition.pattern) {
+		// Use pattern matching via findAll
+		try {
+			candidates = rootNode.findAll(condition.pattern);
+		} catch {
+			return matches;
+		}
+	} else if (condition.kind) {
+		// Manual traversal for kind matching
+		function findByKind(node: any, kind: string): any[] {
+			const results: any[] = [];
+			if (node.kind() === kind) {
+				results.push(node);
+			}
+			for (const child of node.children()) {
+				results.push(...findByKind(child, kind));
+			}
+			return results;
+		}
+		candidates = findByKind(rootNode, condition.kind);
+	} else {
+		// No kind or pattern, search all nodes
+		function getAllNodes(node: any): any[] {
+			const results = [node];
+			for (const child of node.children()) {
+				results.push(...getAllNodes(child));
+			}
+			return results;
+		}
+		candidates = getAllNodes(rootNode);
+	}
+	
+	// Filter candidates by conditions
+	for (const candidate of candidates) {
+		let matchesCondition = true;
+		
+		// Check 'has' condition
+		if (condition.has && matchesCondition) {
+			const subMatches = executeStructuredRule(candidate, condition.has, []);
+			if (subMatches.length === 0) matchesCondition = false;
+		}
+		
+		// Check 'not' condition
+		if (condition.not && matchesCondition) {
+			const subMatches = executeStructuredRule(candidate, condition.not, []);
+			if (subMatches.length > 0) matchesCondition = false;
+		}
+		
+		// Check 'any' condition (at least one must match)
+		if (condition.any && matchesCondition) {
+			let anyMatches = false;
+			for (const subCondition of condition.any) {
+				const subMatches = executeStructuredRule(candidate, subCondition, []);
+				if (subMatches.length > 0) {
+					anyMatches = true;
+					break;
+				}
+			}
+			if (!anyMatches) matchesCondition = false;
+		}
+		
+		// Check 'all' condition (all must match)
+		if (condition.all && matchesCondition) {
+			for (const subCondition of condition.all) {
+				const subMatches = executeStructuredRule(candidate, subCondition, []);
+				if (subMatches.length === 0) {
+					matchesCondition = false;
+					break;
+				}
+			}
+		}
+		
+		// Check 'regex' condition
+		if (condition.regex && matchesCondition) {
+			const text = candidate.text();
+			const regex = new RegExp(condition.regex);
+			if (!regex.test(text)) matchesCondition = false;
+		}
+		
+		if (matchesCondition) {
+			matches.push(candidate);
+		}
+	}
+	
+	return matches;
+}
+
+const astGrepNapiRunner: RunnerDefinition = {
+	id: "ast-grep-napi",
+	appliesTo: ["jsts"], // TypeScript/JavaScript only
+	priority: 15, // Run early (after type checkers, before other linters)
+	enabledByDefault: true,
+	skipTestFiles: true,
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		const startTime = Date.now();
+		
+		if (!canHandle(ctx.filePath)) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const sgModule = await loadSg();
+		if (!sgModule) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		if (!fs.existsSync(ctx.filePath)) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const lang = getLang(ctx.filePath, sgModule);
+		if (!lang) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const content = fs.readFileSync(ctx.filePath, "utf-8");
+		
+		let root: import("@ast-grep/napi").SgRoot;
+		try {
+			root = sgModule.parse(lang, content);
+		} catch {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const diagnostics: Diagnostic[] = [];
+		const rootNode = root.root();
+
+		// Load rules from ts-slop-rules only (complementary to ast-grep CLI)
+		const ruleDirs = [
+			path.join(process.cwd(), "rules/ts-slop-rules/rules"),
+		];
+
+		for (const ruleDir of ruleDirs) {
+			const rules = loadYamlRules(ruleDir);
+			
+			for (const rule of rules) {
+				// Skip rules for different languages (case-insensitive)
+				const lang = rule.language?.toLowerCase();
+				if (lang && lang !== "typescript" && lang !== "javascript") {
+					continue;
+				}
+
+				try {
+					let matches: any[] = [];
+					
+					if (isStructuredRule(rule) && rule.rule) {
+						// Use structured rule execution
+						matches = executeStructuredRule(rootNode, rule.rule, []);
+					} else if (rule.rule?.pattern || rule.rule?.kind) {
+						// Use simple pattern matching
+						const pattern = rule.rule.pattern || rule.rule.kind;
+						if (pattern) {
+							try {
+								matches = rootNode.findAll(pattern);
+							} catch {
+								// Pattern failed, try manual traversal for kind
+								if (rule.rule.kind) {
+									function findByKind(node: any, kind: string): any[] {
+										const results: any[] = [];
+										if (node.kind() === kind) results.push(node);
+										for (const child of node.children()) {
+											results.push(...findByKind(child, kind));
+										}
+										return results;
+									}
+									matches = findByKind(rootNode, rule.rule.kind);
+								}
+							}
+						}
+					}
+					
+					for (const match of matches) {
+						const range = match.range();
+						const weight = rule.metadata?.weight || 3;
+						const severity = weight >= 4 ? "error" : "warning";
+						
+						diagnostics.push({
+							id: `ast-grep-napi-${range.start.line}-${rule.id}`,
+							message: `[${rule.metadata?.category || "slop"}] ${rule.message || rule.id}`,
+							filePath: ctx.filePath,
+							line: range.start.line + 1,
+							column: range.start.column + 1,
+							severity,
+							semantic: severity === "error" ? "blocking" : "warning",
+							tool: "ast-grep-napi",
+							rule: rule.id,
+							fixable: false,
+						});
+					}
+				} catch {
+					// Rule failed, skip
+				}
+			}
+		}
+
+		const elapsed = Date.now() - startTime;
+		if (diagnostics.length > 0 || elapsed > 50) {
+			console.error(`[ast-grep-napi] ${ctx.filePath}: ${elapsed}ms, ${diagnostics.length} issues`);
+		}
+
+		if (diagnostics.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		return {
+			status: "failed",
+			diagnostics,
+			semantic: "warning",
+		};
+	},
+};
+
+export default astGrepNapiRunner;

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

@@ -6,8 +6,30 @@
  * - async/await issues
  * - security anti-patterns
  */
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawn } from "../../safe-spawn.js";
+// Simple YAML fix: field extractor
+function extractFixFromRule(ruleId, ruleDir) {
+    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 = {
     id: "ast-grep",
     appliesTo: ["jsts", "python", "go", "rust", "cxx"],
@@ -15,11 +37,9 @@ const astGrepRunner = {
     enabledByDefault: false,
     skipTestFiles: true, // Many rules are noisy in tests
     async run(ctx) {
-        // 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) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -29,19 +49,17 @@ const astGrepRunner = {
         if (!configPath) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        // Run ast-grep scan on the file
-        const args = ["scan", "--config", configPath, "--json", ctx.filePath];
-        const result = spawnSync("sg", args, {
-            encoding: "utf-8",
+        // Run ast-grep scan on the file (use npx for local installs)
+        const args = ["sg", "scan", "--config", configPath, "--json", ctx.filePath];
+        const result = safeSpawn("npx", args, {
             timeout: 30000,
-            shell: true,
         });
         const raw = result.stdout + result.stderr;
         if (result.status === 0 && !raw.trim()) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
         // 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" };
         }
@@ -66,27 +84,52 @@ function findAstGrepConfig(cwd) {
     }
     return undefined;
 }
-function parseAstGrepOutput(raw, filePath) {
+function parseAstGrepOutput(raw, filePath, _configPath) {
     const diagnostics = [];
     // 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;
+                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,
                 });
             }
         }