pi-lens 2.0.37 → 2.0.39

package/clients/sg-runner.ts

@@ -0,0 +1,168 @@
+/**
+ * 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 interface SgMatch {
+	file: string;
+	range: {
+		start: { line: number; column: number };
+		end: { line: number; column: number };
+	};
+	text: string;
+	replacement?: string;
+}
+
+export interface SgResult {
+	matches: SgMatch[];
+	error?: string;
+}
+
+export class SgRunner {
+	private log: (msg: string) => void;
+
+	constructor(verbose = false) {
+		this.log = verbose ? (msg: string) => console.error(`[sg-runner] ${msg}`) : () => {};
+	}
+
+	/**
+	 * Check if ast-grep CLI is available
+	 */
+	isAvailable(): boolean {
+		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: string[]): Promise<SgResult> {
+		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: Buffer) => (stdout += data.toString()));
+			proc.stderr.on("data", (data: Buffer) => (stderr += data.toString()));
+
+			proc.on("error", (err: Error) => {
+				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: number | null) => {
+				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: string[]): { output: string; error?: string } {
+		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: string, ruleId: string, ruleYaml: string, timeout = 30000): SgMatch[] {
+		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 as Error).message}`);
+			}
+		}
+	}
+
+	/**
+	 * Format matches for display
+	 */
+	formatMatches(matches: SgMatch[], isDryRun = false, maxItems = 50): string {
+		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");
+	}
+}

package/clients/subprocess-client.js

@@ -1,20 +1,4 @@
-/**
- * Base class for CLI tool clients that communicate via subprocess.
- *
- * Provides common patterns for:
- * - Availability checking (cached)
- * - File type detection
- * - Running CLI commands
- * - Logging
- *
- * Subclasses implement:
- * - getToolName(): The CLI tool name
- * - getCheckCommand(): Command to check availability
- * - isSupportedFile(): File extensions the tool handles
- * - parseOutput(): Parse CLI output into diagnostics
- */
 import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
 import * as path from "node:path";
 export class SubprocessClient {
     constructor(verbose = false) {
@@ -24,9 +8,6 @@ export class SubprocessClient {
             ? (msg) => console.error(`[${this.toolName}] ${msg}`)
             : () => { };
     }
-    /**
-     * Check if the CLI tool is available (cached)
-     */
     isAvailable() {
         if (this.available !== null)
             return this.available;
@@ -51,16 +32,10 @@ export class SubprocessClient {
         }
         return this.available;
     }
-    /**
-     * Check if a file is supported by this tool
-     */
     isSupportedFile(filePath) {
         const ext = path.extname(filePath).toLowerCase();
         return this.getSupportedExtensions().includes(ext);
     }
-    /**
-     * Run a command and return the result
-     */
     runCommand(cmd, options = {}) {
         const { cwd, timeout = 15000, input } = options;
         try {
@@ -86,16 +61,4 @@ export class SubprocessClient {
             };
         }
     }
-    /**
-     * Resolve a file path to absolute
-     */
-    resolvePath(filePath) {
-        return path.resolve(filePath);
-    }
-    /**
-     * Check if a file exists
-     */
-    fileExists(filePath) {
-        return fs.existsSync(filePath);
-    }
 }

package/clients/subprocess-client.ts

@@ -1,21 +1,4 @@
-/**
- * Base class for CLI tool clients that communicate via subprocess.
- *
- * Provides common patterns for:
- * - Availability checking (cached)
- * - File type detection
- * - Running CLI commands
- * - Logging
- *
- * Subclasses implement:
- * - getToolName(): The CLI tool name
- * - getCheckCommand(): Command to check availability
- * - isSupportedFile(): File extensions the tool handles
- * - parseOutput(): Parse CLI output into diagnostics
- */
-
 import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
 import * as path from "node:path";
 
 export interface Diagnostic {
@@ -42,31 +25,11 @@ export abstract class SubprocessClient<T extends Diagnostic> {
 			: () => {};
 	}
 
-	/**
-	 * The name of the CLI tool (used in log messages)
-	 */
 	protected abstract getToolName(): string;
-
-	/**
-	 * Command and args to check if the tool is available
-	 * e.g., ["ruff", "--version"] or ["npx", "@biomejs/biome", "--version"]
-	 */
 	protected abstract getCheckCommand(): string[];
-
-	/**
-	 * File extensions this tool supports (with dots)
-	 * e.g., [".py"] or [".ts", ".tsx", ".js", ".jsx"]
-	 */
 	protected abstract getSupportedExtensions(): string[];
-
-	/**
-	 * Parse CLI output into diagnostics
-	 */
 	protected abstract parseOutput(output: string, filePath: string): T[];
 
-	/**
-	 * Check if the CLI tool is available (cached)
-	 */
 	isAvailable(): boolean {
 		if (this.available !== null) return this.available;
 
@@ -92,22 +55,13 @@ export abstract class SubprocessClient<T extends Diagnostic> {
 		return this.available;
 	}
 
-	/**
-	 * Check if a file is supported by this tool
-	 */
 	isSupportedFile(filePath: string): boolean {
 		const ext = path.extname(filePath).toLowerCase();
 		return this.getSupportedExtensions().includes(ext);
 	}
 
-	/**
-	 * Run the tool on a file and return diagnostics
-	 */
 	abstract checkFile(filePath: string): T[];
 
-	/**
-	 * Run a command and return the result
-	 */
 	protected runCommand(
 		cmd: string[],
 		options: {
@@ -142,18 +96,4 @@ export abstract class SubprocessClient<T extends Diagnostic> {
 			} as unknown as ReturnType<typeof spawnSync>;
 		}
 	}
-
-	/**
-	 * Resolve a file path to absolute
-	 */
-	protected resolvePath(filePath: string): string {
-		return path.resolve(filePath);
-	}
-
-	/**
-	 * Check if a file exists
-	 */
-	protected fileExists(filePath: string): boolean {
-		return fs.existsSync(filePath);
-	}
 }

package/clients/ts-service.ts

@@ -6,7 +6,6 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
 import * as ts from "typescript";
 
 export class TypeScriptService {
@@ -120,12 +119,7 @@ export class TypeScriptService {
 				return null;
 			}
 		}
-		return ts.createSourceFile(
-			filePath,
-			content,
-			ts.ScriptTarget.Latest,
-			true,
-		);
+		return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
 	}
 
 	/**

package/clients/type-safety-client.js

@@ -100,7 +100,8 @@ export class TypeSafetyClient {
                     // Find missing cases
                     const missingCases = literalValues.filter((v) => !coveredCases.has(v));
                     if (missingCases.length > 0 && !hasDefault) {
-                        const line = programSourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                        const line = programSourceFile.getLineAndCharacterOfPosition(node.getStart())
+                            .line + 1;
                         const exprText = node.expression.getText(programSourceFile);
                         const typeStr = missingCases.map((c) => `'${c}'`).join(", ");
                         issues.push({
@@ -134,10 +135,4 @@ export class TypeSafetyClient {
     }
 }
 // --- Singleton ---
-let instance = null;
-export function getTypeSafetyClient(verbose = false) {
-    if (!instance) {
-        instance = new TypeSafetyClient(verbose);
-    }
-    return instance;
-}
+const _instance = null;

package/clients/type-safety-client.ts

@@ -90,7 +90,9 @@ export class TypeSafetyClient {
 
 		// Use the source file from the program (has proper type information)
 		const tsService = getTypeScriptService();
-		const programSourceFile = tsService.getSourceFileFromProgram(sourceFile.fileName);
+		const programSourceFile = tsService.getSourceFileFromProgram(
+			sourceFile.fileName,
+		);
 		if (!programSourceFile) return;
 
 		const visit = (node: ts.Node) => {
@@ -103,7 +105,9 @@ export class TypeSafetyClient {
 
 					// Get all literal values from the union
 					const literalValues = unionTypes
-						.filter((t) => t.isLiteral() || t.flags & ts.TypeFlags.BooleanLiteral)
+						.filter(
+							(t) => t.isLiteral() || t.flags & ts.TypeFlags.BooleanLiteral,
+						)
 						.map((t) => {
 							if (t.isLiteral()) {
 								return String(t.value);
@@ -143,9 +147,9 @@ export class TypeSafetyClient {
 					);
 
 					if (missingCases.length > 0 && !hasDefault) {
-						const line = programSourceFile.getLineAndCharacterOfPosition(
-							node.getStart(),
-						).line + 1;
+						const line =
+							programSourceFile.getLineAndCharacterOfPosition(node.getStart())
+								.line + 1;
 
 						const exprText = node.expression.getText(programSourceFile);
 						const typeStr = missingCases.map((c) => `'${c}'`).join(", ");
@@ -184,16 +188,8 @@ export class TypeSafetyClient {
 		}
 		return checker;
 	}
-
 }
 
 // --- Singleton ---
 
-let instance: TypeSafetyClient | null = null;
-
-export function getTypeSafetyClient(verbose = false): TypeSafetyClient {
-	if (!instance) {
-		instance = new TypeSafetyClient(verbose);
-	}
-	return instance;
-}
+const _instance: TypeSafetyClient | null = null;

package/clients/typescript-client.js

@@ -264,58 +264,61 @@ export class TypeScriptClient {
             ls: this.languageService,
         };
     }
-    /**
-     * Go to definition
-     */
-    getDefinition(filePath, line, character) {
+    withPosition(filePath, line, character, cb) {
         const resolved = this.resolvePosition(filePath, line, character);
         if (!resolved)
             return [];
         const { normalized, position, ls } = resolved;
-        const definitions = ls.getDefinitionAtPosition(normalized, position);
-        if (!definitions)
-            return [];
-        return definitions.map((def) => {
-            if (def.textSpan) {
-                const defFile = def.fileName || normalized;
-                const defContent = this.fileContents.get(defFile) || "";
-                if (defContent) {
-                    const lines = defContent.substring(0, def.textSpan.start).split("\n");
-                    return {
-                        file: defFile,
-                        line: lines.length - 1,
-                        character: lines[lines.length - 1].length,
-                    };
+        return cb(normalized, position, ls) ?? [];
+    }
+    /**
+     * Go to definition
+     */
+    getDefinition(filePath, line, character) {
+        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
+            const definitions = ls.getDefinitionAtPosition(normalized, position);
+            if (!definitions)
+                return undefined;
+            return definitions.map((def) => {
+                if (def.textSpan) {
+                    const defFile = def.fileName || normalized;
+                    const defContent = this.fileContents.get(defFile) || "";
+                    if (defContent) {
+                        const lines = defContent
+                            .substring(0, def.textSpan.start)
+                            .split("\n");
+                        return {
+                            file: defFile,
+                            line: lines.length - 1,
+                            character: lines[lines.length - 1].length,
+                        };
+                    }
                 }
-            }
-            return { file: def.fileName, line: 0, character: 0 };
+                return { file: def.fileName, line: 0, character: 0 };
+            });
         });
     }
     /**
      * Get type definition
      */
     getTypeDefinition(filePath, line, character) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return [];
-        const { normalized, position, ls } = resolved;
-        const defs = ls.getTypeDefinitionAtPosition(normalized, position);
-        if (!defs)
-            return [];
-        return this.toLocations(defs, normalized);
+        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
+            const defs = ls.getTypeDefinitionAtPosition(normalized, position);
+            if (!defs)
+                return undefined;
+            return this.toLocations(defs, normalized);
+        });
     }
     /**
      * Find references
      */
     getReferences(filePath, line, character) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return [];
-        const { normalized, position, ls } = resolved;
-        const references = ls.getReferencesAtPosition(normalized, position);
-        if (!references)
-            return [];
-        return this.toLocations(references);
+        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
+            const references = ls.getReferencesAtPosition(normalized, position);
+            if (!references)
+                return undefined;
+            return this.toLocations(references);
+        });
     }
     /** Map TS definition/reference entries to Location objects. */
     toLocations(entries, fallbackFile) {
@@ -369,31 +372,27 @@ export class TypeScriptClient {
      * Get completions at a position
      */
     getCompletions(filePath, line, character) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return [];
-        const { normalized, position, ls } = resolved;
-        const completions = ls.getCompletionsAtPosition(normalized, position, {});
-        if (!completions)
-            return [];
-        return completions.entries.slice(0, 50).map((entry) => ({
-            name: entry.name,
-            kind: this.completionKind(entry.kind),
-            sortText: entry.sortText,
-        }));
+        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
+            const completions = ls.getCompletionsAtPosition(normalized, position, {});
+            if (!completions)
+                return undefined;
+            return completions.entries.slice(0, 50).map((entry) => ({
+                name: entry.name,
+                kind: this.completionKind(entry.kind),
+                sortText: entry.sortText,
+            }));
+        });
     }
     /**
      * Go to implementation
      */
     getImplementation(filePath, line, character) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return [];
-        const { normalized, position, ls } = resolved;
-        const implementations = ls.getImplementationAtPosition(normalized, position);
-        if (!implementations)
-            return [];
-        return this.toLocations(implementations);
+        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
+            const implementations = ls.getImplementationAtPosition(normalized, position);
+            if (!implementations)
+                return undefined;
+            return this.toLocations(implementations);
+        });
     }
     /**
      * Get folding ranges