pi-lens 2.2.9 → 3.0.0

package/clients/tree-sitter-query-loader.ts

@@ -0,0 +1,425 @@
+/**
+ * Tree-sitter Query Loader
+ *
+ * Loads tree-sitter queries from YAML files in rules/tree-sitter-queries/
+ * and provides them to the TreeSitterClient.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export interface TreeSitterQuery {
+	id: string;
+	name: string;
+	severity: "error" | "warning" | "info";
+	category: string;
+	language: string;
+	message: string;
+	description?: string;
+	query: string;
+	metavars: string[];
+	post_filter?: string;
+	// biome-ignore lint/suspicious/noExplicitAny: Flexible filter params
+	post_filter_params?: Record<string, any>;
+	tags?: string[];
+	has_fix: boolean;
+	fix_action?: string;
+	examples?: {
+		bad?: string;
+		good?: string;
+	};
+	filePath: string;
+}
+
+export class TreeSitterQueryLoader {
+	private queries: Map<string, TreeSitterQuery[]> = new Map();
+	private loaded = false;
+	private verbose: boolean;
+
+	constructor(verbose = false) {
+		this.verbose = verbose;
+	}
+
+	/** Debug logging helper */
+	private dbg(msg: string): void {
+		if (this.verbose) {
+			console.error(`[query-loader] ${msg}`);
+		}
+	}
+
+	/**
+	 * Load all queries from the rules/tree-sitter-queries directory
+	 */
+	async loadQueries(): Promise<Map<string, TreeSitterQuery[]>> {
+		if (this.loaded) return this.queries;
+
+		const queriesDir = path.join(process.cwd(), "rules", "tree-sitter-queries");
+
+		if (!fs.existsSync(queriesDir)) {
+			this.dbg(`Queries directory not found: ${queriesDir}`);
+			return this.queries;
+		}
+
+		// Load queries from each language subdirectory
+		const languageDirs = fs
+			.readdirSync(queriesDir, { withFileTypes: true })
+			.filter((d) => d.isDirectory())
+			.map((d) => d.name);
+
+		for (const lang of languageDirs) {
+			const langDir = path.join(queriesDir, lang);
+			const queryFiles = fs
+				.readdirSync(langDir)
+				.filter((f) => f.endsWith(".yml"));
+
+			const langQueries: TreeSitterQuery[] = [];
+
+			for (const file of queryFiles) {
+				const filePath = path.join(langDir, file);
+				const query = this.parseQueryFile(filePath, lang);
+				if (query) {
+					langQueries.push(query);
+				}
+			}
+
+			if (langQueries.length > 0) {
+				this.queries.set(lang, langQueries);
+				this.dbg(`Loaded ${langQueries.length} queries for ${lang}`);
+			}
+		}
+
+		this.loaded = true;
+		return this.queries;
+	}
+
+	/**
+	 * Parse a single YAML query file
+	 */
+	private parseQueryFile(
+		filePath: string,
+		language: string,
+	): TreeSitterQuery | null {
+		try {
+			const content = fs.readFileSync(filePath, "utf-8");
+
+			// Simple YAML parsing (extract key: value pairs)
+			const parsed = this.parseYaml(content);
+
+			if (!parsed.id || !parsed.query) {
+				this.dbg(`Invalid query file: ${filePath}`);
+				return null;
+			}
+
+			return {
+				id: String(parsed.id),
+				name: String(parsed.name || parsed.id),
+				severity: this.parseSeverity(parsed.severity),
+				category: String(parsed.category || "general"),
+				language: String(parsed.language || language),
+				message: String(parsed.message || `Pattern: ${parsed.id}`),
+				description: parsed.description
+					? String(parsed.description)
+					: undefined,
+				query:
+					this.extractMultilineValue(content, "query") || String(parsed.query),
+				metavars: Array.isArray(parsed.metavars)
+					? parsed.metavars.map(String)
+					: this.extractMetavars(String(parsed.query)),
+				post_filter: parsed.post_filter
+					? String(parsed.post_filter)
+					: undefined,
+				// biome-ignore lint/suspicious/noExplicitAny: Post filter params
+				post_filter_params: parsed.post_filter_params as any,
+				tags: Array.isArray(parsed.tags) ? parsed.tags.map(String) : undefined,
+				has_fix: parsed.has_fix === true || parsed.has_fix === "true",
+				fix_action: parsed.fix_action ? String(parsed.fix_action) : undefined,
+				filePath,
+			};
+		} catch (err) {
+			this.dbg(`Failed to parse ${filePath}: ${err}`);
+			return null;
+		}
+	}
+
+	/**
+	 * Simple YAML parser for our query files
+	 */
+	private parseYaml(
+		content: string,
+	): Record<string, string | string[] | boolean> {
+		const result: Record<string, string | string[] | boolean> = {};
+		const lines = content.split("\n");
+
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			const match = line.match(/^([a-z_]+):\s*(.*)$/);
+			if (match) {
+				const key = match[1];
+				let value: string | string[] | boolean = match[2].trim();
+
+				// Handle arrays inline: metavars: [A, B, C]
+				if (value.startsWith("[") && value.endsWith("]")) {
+					value = value
+						.slice(1, -1)
+						.split(",")
+						.map((s) => s.trim().replace(/^["']|["']$/g, ""));
+				}
+				// Handle multi-line arrays: metavars:\n  - A\n  - B
+				else if (value === "") {
+					// Check if next lines are array items (  - item)
+					const arrayItems: string[] = [];
+					const baseIndent = line.match(/^(\s*)/)?.[0].length || 0;
+
+					for (let j = i + 1; j < lines.length; j++) {
+						const nextLine = lines[j];
+						const nextIndent = nextLine.match(/^(\s*)/)?.[0].length || 0;
+
+						// Stop if we hit a line with same or less indent (new key)
+						if (nextIndent <= baseIndent && nextLine.match(/^[a-z_]+:/)) {
+							break;
+						}
+
+						// Check if it's an array item
+						const itemMatch = nextLine.match(/^\s+-\s*(.+)$/);
+						if (itemMatch) {
+							// Strip inline comments and trim
+							const item = itemMatch[1].trim().replace(/\s*#.*$/, "");
+							if (item) arrayItems.push(item);
+						}
+					}
+
+					if (arrayItems.length > 0) {
+						value = arrayItems;
+					}
+				}
+				// Handle booleans
+				else if (value === "true") value = true;
+				else if (value === "false") value = false;
+				// Strip quotes from strings
+				else if (value.startsWith('"') && value.endsWith('"')) {
+					value = value.slice(1, -1);
+				}
+
+				result[key] = value;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Extract a multiline value (like query) from YAML
+	 */
+	private extractMultilineValue(content: string, key: string): string | null {
+		const lines = content.split("\n");
+		let startLine = -1;
+		let startIndent = 0;
+
+		const keyPrefix = `${key}:`;
+
+		// Find the key line
+		for (let i = 0; i < lines.length; i++) {
+			const trimmed = lines[i].trimStart();
+			if (trimmed.startsWith(keyPrefix)) {
+				startLine = i;
+				startIndent = lines[i].length - trimmed.length;
+				const afterKey = trimmed.slice(keyPrefix.length).trim();
+				// If there's content on the same line (not just |), return it
+				if (afterKey && afterKey !== "|") return afterKey;
+				break;
+			}
+		}
+
+		if (startLine === -1) return null;
+
+		// Collect all lines until we hit a new key with same or less indent
+		const valueLines: string[] = [];
+		for (let i = startLine + 1; i < lines.length; i++) {
+			const line = lines[i];
+
+			// Track empty lines
+			if (!line.trim()) {
+				valueLines.push("");
+				continue;
+			}
+
+			// Check indent
+			const indentMatch = line.match(/^(\s*)/);
+			const indent = indentMatch ? indentMatch[1].length : 0;
+			const trimmed = line.trim();
+
+			// Stop at new key with same or less indent (but not at comments)
+			if (
+				indent <= startIndent &&
+				trimmed.match(/^[a-z_]+:/) &&
+				!trimmed.startsWith("#")
+			) {
+				break;
+			}
+
+			// Skip comment lines (they're not part of the value)
+			if (trimmed.startsWith("#")) continue;
+
+			// This is part of the multiline value
+			valueLines.push(line.slice(startIndent));
+		}
+
+		// Clean up - remove trailing empty lines
+		while (valueLines.length > 0 && !valueLines[valueLines.length - 1].trim()) {
+			valueLines.pop();
+		}
+
+		return valueLines.length > 0 ? valueLines.join("\n") : null;
+	}
+
+	/**
+	 * Parse severity string to valid type
+	 */
+	private parseSeverity(value: unknown): "error" | "warning" | "info" {
+		if (value === "error") return "error";
+		if (value === "warning") return "warning";
+		if (value === "info") return "info";
+		return "warning"; // default
+	}
+
+	/**
+	 * Extract @VAR patterns from query string
+	 */
+	private extractMetavars(query: string): string[] {
+		const matches = query.match(/@([A-Z_][A-Z0-9_]*)/g);
+		if (!matches) return [];
+		return [...new Set(matches.map((m) => m.slice(1)))];
+	}
+
+	/**
+	 * Get queries for a specific language
+	 */
+	getQueriesForLanguage(language: string): TreeSitterQuery[] {
+		return this.queries.get(language) || [];
+	}
+
+	/**
+	 * Get a specific query by ID
+	 */
+	getQueryById(id: string): TreeSitterQuery | undefined {
+		for (const langQueries of this.queries.values()) {
+			const query = langQueries.find((q) => q.id === id);
+			if (query) return query;
+		}
+		return undefined;
+	}
+
+	/**
+	 * Find matching query for a pattern string
+	 */
+	findMatchingQuery(
+		pattern: string,
+		language: string,
+	): TreeSitterQuery | undefined {
+		const langQueries = this.getQueriesForLanguage(language);
+
+		// Check for pattern keywords
+		for (const query of langQueries) {
+			// Match by ID
+			if (pattern.includes(query.id)) return query;
+
+			// Match by keywords in pattern
+			switch (query.id) {
+				case "empty-catch":
+					if (pattern.includes("empty-catch") || pattern.includes("catch {}"))
+						return query;
+					break;
+				case "debugger-statement":
+					if (pattern.includes("debugger")) return query;
+					break;
+				case "await-in-loop":
+					if (pattern.includes("await-in-loop") || pattern.includes("await"))
+						return query;
+					break;
+				case "hardcoded-secrets":
+					if (
+						pattern.includes("hardcoded") ||
+						pattern.includes("api_key") ||
+						pattern.includes("password")
+					)
+						return query;
+					break;
+				case "dangerously-set-inner-html":
+					if (pattern.includes("dangerously") || pattern.includes("innerHTML"))
+						return query;
+					break;
+				case "nested-ternary":
+					if (pattern.includes("ternary") || pattern.includes("? :"))
+						return query;
+					break;
+				case "no-eval":
+					if (pattern.includes("eval") && !pattern.includes("console"))
+						return query;
+					break;
+				case "deep-promise-chain":
+					if (pattern.includes(".then") && pattern.includes(".catch"))
+						return query;
+					break;
+				case "console-statement":
+					if (pattern.includes("console")) return query;
+					break;
+				case "long-parameter-list":
+					if (pattern.includes("PARAMS")) return query;
+					break;
+				// Python queries
+				case "bare-except":
+					if (pattern.includes("bare-except") || pattern.includes("except:"))
+						return query;
+					break;
+				case "mutable-default-arg":
+					if (pattern.includes("mutable") || pattern.includes("default"))
+						return query;
+					break;
+				case "wildcard-import":
+					if (pattern.includes("wildcard") || pattern.includes("import *"))
+						return query;
+					break;
+				case "eval-exec":
+					if (pattern.includes("eval") || pattern.includes("exec"))
+						return query;
+					break;
+				case "is-vs-equals":
+					if (pattern.includes("is") || pattern.includes("equals"))
+						return query;
+					break;
+				case "unreachable-except":
+					if (pattern.includes("unreachable") || pattern.includes("except"))
+						return query;
+					break;
+			}
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Get all loaded queries
+	 */
+	getAllQueries(): TreeSitterQuery[] {
+		const all: TreeSitterQuery[] = [];
+		for (const queries of this.queries.values()) {
+			all.push(...queries);
+		}
+		return all;
+	}
+
+	/**
+	 * Reload queries from disk
+	 */
+	async reload(): Promise<void> {
+		this.queries.clear();
+		this.loaded = false;
+		await this.loadQueries();
+	}
+}
+
+// Singleton instance
+export const queryLoader = new TreeSitterQueryLoader();

package/clients/type-coverage-client.js

@@ -8,8 +8,8 @@
  * Requires: npm install -D type-coverage
  * Docs: https://github.com/plantain-00/type-coverage
  */
-import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 // --- Client ---
 export class TypeCoverageClient {
     constructor(verbose = false) {
@@ -21,10 +21,8 @@ export class TypeCoverageClient {
     isAvailable() {
         if (this.available !== null)
             return this.available;
-        const result = spawnSync("npx", ["type-coverage", "--version"], {
-            encoding: "utf-8",
+        const result = safeSpawn("npx", ["type-coverage", "--version"], {
             timeout: 10000,
-            shell: true,
         });
         this.available = !result.error && result.status === 0;
         return this.available;
@@ -45,17 +43,15 @@ export class TypeCoverageClient {
             };
         }
         try {
-            const result = spawnSync("npx", [
+            const result = safeSpawn("npx", [
                 "type-coverage",
                 "--detail",
                 "--strict",
                 "--ignore-files",
                 "**/*.d.ts",
             ], {
-                encoding: "utf-8",
                 timeout: 30000,
                 cwd,
-                shell: true,
             });
             const output = (result.stdout ?? "") + (result.stderr ?? "");
             return this.parseOutput(output, cwd);

package/clients/type-coverage-client.ts

@@ -11,6 +11,7 @@
 
 import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 
 // --- Types ---
 
@@ -43,10 +44,8 @@ export class TypeCoverageClient {
 
 	isAvailable(): boolean {
 		if (this.available !== null) return this.available;
-		const result = spawnSync("npx", ["type-coverage", "--version"], {
-			encoding: "utf-8",
+		const result = safeSpawn("npx", ["type-coverage", "--version"], {
 			timeout: 10000,
-			shell: true,
 		});
 		this.available = !result.error && result.status === 0;
 		return this.available;
@@ -69,7 +68,7 @@ export class TypeCoverageClient {
 		}
 
 		try {
-			const result = spawnSync(
+			const result = safeSpawn(
 				"npx",
 				[
 					"type-coverage",
@@ -79,10 +78,8 @@ export class TypeCoverageClient {
 					"**/*.d.ts",
 				],
 				{
-					encoding: "utf-8",
 					timeout: 30000,
 					cwd,
-					shell: true,
 				},
 			);
 

package/clients/typescript-client.codefix.test.js

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
+import { TypeScriptClient } from "./typescript-client.js";
+describe("TypeScriptClient - Code Fixes", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new TypeScriptClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-codefix-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("getCodeFixes", () => {
+        it("should provide fix for missing property on object literal", () => {
+            // Real-world case: Missing required property in object literal
+            const content = `
+interface Config {
+  name: string;
+  port: number;
+  debug: boolean;
+}
+
+const config: Config = {
+  name: "my-app",
+  port: 3000
+  // Missing 'debug' property - TS2345
+};
+`;
+            const filePath = createTempFile(tmpDir, "missing-property.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            const missingPropError = diags.find((d) => d.code === 2345 || d.message.includes("missing"));
+            if (missingPropError) {
+                const line = missingPropError.range.start.line;
+                const char = missingPropError.range.start.character;
+                const fixes = client.getCodeFixes(filePath, line, char, [
+                    missingPropError.code,
+                ]);
+                // TypeScript should suggest adding the missing property
+                expect(fixes.length).toBeGreaterThan(0);
+                const hasAddPropertyFix = fixes.some((f) => f.description.toLowerCase().includes("add") ||
+                    f.description.toLowerCase().includes("property") ||
+                    f.description.toLowerCase().includes("declare"));
+                expect(hasAddPropertyFix).toBe(true);
+            }
+        });
+        it("should provide fix for missing await in async function", () => {
+            // Real-world case: Forgetting await on a Promise-returning function
+            const content = `
+async function fetchUser(id: string): Promise<{ name: string }> {
+  return { name: "John" };
+}
+
+async function getUserName(id: string): Promise<string> {
+  const user = fetchUser(id); // Missing await
+  return user.name; // Type 'Promise<{ name: string; }>' has no property 'name'
+}
+`;
+            const filePath = createTempFile(tmpDir, "missing-await.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            // TS2739: Type 'Promise<{ name: string; }>' is missing 'name'
+            const propertyError = diags.find((d) => d.code === 2739 || d.message.includes("is missing"));
+            if (propertyError) {
+                const fixes = client.getAllCodeFixes(filePath);
+                // If there's an error, check if we have fixes for it
+                const lineFixes = fixes.get(propertyError.range.start.line);
+                if (lineFixes) {
+                    expect(lineFixes.length).toBeGreaterThan(0);
+                }
+            }
+            // Test passes if we get here - not all TS versions provide fixes for this
+            expect(true).toBe(true);
+        });
+        it("should provide fix for incorrect type assignment", () => {
+            // Real-world case: String instead of number
+            const content = `
+function calculateTotal(price: number, tax: number): number {
+  return price + tax;
+}
+
+const result = calculateTotal("100", 10); // TS2345: Argument of type 'string' is not assignable to parameter of type 'number'
+`;
+            const filePath = createTempFile(tmpDir, "type-mismatch.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            const typeError = diags.find((d) => d.code === 2345);
+            if (typeError) {
+                const line = typeError.range.start.line;
+                const char = typeError.range.start.character;
+                const fixes = client.getCodeFixes(filePath, line, char, [2345]);
+                // TypeScript often suggests fixes for type mismatches
+                expect(fixes).toBeDefined();
+            }
+        });
+        it("should collect all fixes via getAllCodeFixes", () => {
+            // Multiple errors in one file
+            const content = `
+interface Person {
+  name: string;
+  age: number;
+}
+
+const person: Person = {
+  name: "Alice"
+  // Missing age
+};
+
+function greet(p: Person): string {
+  return "Hello " + p.name;
+}
+
+greet({ name: "Bob" }); // Missing age in argument
+`;
+            const filePath = createTempFile(tmpDir, "multiple-errors.ts", content);
+            client.addFile(filePath, content);
+            const allFixes = client.getAllCodeFixes(filePath);
+            // Should have fixes mapped by line number
+            expect(allFixes).toBeInstanceOf(Map);
+            // Each fix entry should have a description and changes
+            for (const [line, fixes] of allFixes.entries()) {
+                expect(typeof line).toBe("number");
+                expect(fixes.length).toBeGreaterThan(0);
+                for (const fix of fixes) {
+                    expect(fix.description).toBeTruthy();
+                    expect(fix.changes).toBeDefined();
+                }
+            }
+        });
+    });
+    describe("Integration with diagnostic messages", () => {
+        it("should include fix suggestions in getAllCodeFixes output", () => {
+            const content = `
+class User {
+  constructor(public name: string) {}
+}
+
+const user = new User(); // TS2554: Expected 1 arguments, but got 0
+`;
+            const filePath = createTempFile(tmpDir, "constructor-args.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            const argError = diags.find((d) => d.code === 2554);
+            if (argError) {
+                const fixes = client.getAllCodeFixes(filePath);
+                const lineFixes = fixes.get(argError.range.start.line);
+                if (lineFixes && lineFixes.length > 0) {
+                    // The runner would append this to the message
+                    const suggestion = lineFixes[0].description;
+                    expect(suggestion).toBeTruthy();
+                }
+            }
+        });
+    });
+});