pi-lens 2.2.9 → 3.0.0

package/clients/ast-grep-client.ts

@@ -13,7 +13,13 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { AstGrepParser } from "./ast-grep-parser.js";
 import { AstGrepRuleManager } from "./ast-grep-rule-manager.js";
-import { type SgMatch, SgRunner } from "./sg-runner.js";
+import type {
+	AstGrepDiagnostic,
+	AstGrepMatch,
+	RuleDescription,
+	SgMatch,
+} from "./ast-grep-types.js";
+import { SgRunner } from "./sg-runner.js";
 
 const _getExtensionDir = () => {
 	if (typeof __dirname !== "undefined") {
@@ -22,39 +28,6 @@ const _getExtensionDir = () => {
 	return ".";
 };
 
-// --- Types ---
-
-export interface RuleDescription {
-	id: string;
-	message: string;
-	note?: string;
-	severity: "error" | "warning" | "info" | "hint";
-	grade?: number;
-}
-
-export interface AstGrepMatch {
-	file: string;
-	range: {
-		start: { line: number; column: number };
-		end: { line: number; column: number };
-	};
-	text: string;
-	replacement?: string;
-}
-
-export interface AstGrepDiagnostic {
-	line: number;
-	column: number;
-	endLine: number;
-	endColumn: number;
-	severity: "error" | "warning" | "info" | "hint";
-	message: string;
-	rule: string;
-	ruleDescription?: RuleDescription;
-	file: string;
-	fix?: string;
-}
-
 // --- Client ---
 
 export class AstGrepClient {
@@ -140,7 +113,7 @@ export class AstGrepClient {
 		ruleId: string,
 		ruleYaml: string,
 		timeout = 30000,
-	): any[] {
+	): AstGrepMatch[] {
 		if (!this.isAvailable()) return [];
 		return this.runner.tempScan(dir, ruleId, ruleYaml, timeout);
 	}
@@ -171,7 +144,7 @@ message: found
 		return this.groupSimilarFunctions(matches);
 	}
 
-	private groupSimilarFunctions(matches: any[]): Array<{
+	private groupSimilarFunctions(matches: AstGrepMatch[]): Array<{
 		pattern: string;
 		functions: Array<{ name: string; file: string; line: number }>;
 	}> {
@@ -289,7 +262,7 @@ message: found
 				{
 					encoding: "utf-8",
 					timeout: 15000,
-					shell: true,
+					shell: process.platform === "win32",
 				},
 			);
 
@@ -302,8 +275,10 @@ message: found
 				(sev) => this.mapSeverity(sev),
 			);
 			return parser.parseOutput(output, absolutePath);
-		} catch (err: any) {
-			this.log(`Scan error: ${err.message}`);
+		} catch (err) {
+			this.log(
+				`Scan error: ${err instanceof Error ? err.message : String(err)}`,
+			);
 			return [];
 		}
 	}

package/clients/ast-grep-parser.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import type { AstGrepDiagnostic, RuleDescription } from "./ast-grep-client.js";
+import type { AstGrepDiagnostic, RuleDescription } from "./ast-grep-types.js";
 
 // New ast-grep JSON format
 export interface AstGrepJsonDiagnostic {

package/clients/ast-grep-rule-manager.js

@@ -63,6 +63,14 @@ export class AstGrepRuleManager {
         const gradeMatch = content.match(/Grade\s+(\d+\.\d+)/i);
         if (gradeMatch)
             result.grade = parseFloat(gradeMatch[1]);
+        const fixMatch = content.match(/^fix:\s*\|?([\s\S]*?)(?=^\w|^rule:|Z)/m);
+        if (fixMatch) {
+            result.fix = fixMatch[1]
+                .split("\n")
+                .map((line) => line.replace(/^\s*\|?\s*/, ""))
+                .filter((line) => line.length > 0)
+                .join("\n");
+        }
         if (result.id && result.message) {
             return result;
         }

package/clients/ast-grep-rule-manager.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { RuleDescription } from "./ast-grep-client.js";
+import type { RuleDescription } from "./ast-grep-types.js";
 
 export class AstGrepRuleManager {
 	private ruleDescriptions: Map<string, RuleDescription> | null = null;
@@ -79,6 +79,15 @@ export class AstGrepRuleManager {
 		const gradeMatch = content.match(/Grade\s+(\d+\.\d+)/i);
 		if (gradeMatch) result.grade = parseFloat(gradeMatch[1]);
 
+		const fixMatch = content.match(/^fix:\s*\|?([\s\S]*?)(?=^\w|^rule:|Z)/m);
+		if (fixMatch) {
+			result.fix = fixMatch[1]
+				.split("\n")
+				.map((line) => line.replace(/^\s*\|?\s*/, ""))
+				.filter((line) => line.length > 0)
+				.join("\n");
+		}
+
 		if (result.id && result.message) {
 			return result as RuleDescription;
 		}

package/clients/ast-grep-types.js

@@ -0,0 +1,9 @@
+/**
+ * Shared types for ast-grep client, parser, and rule manager.
+ *
+ * Extracted to prevent circular dependencies between:
+ * - ast-grep-client.ts
+ * - ast-grep-parser.ts
+ * - ast-grep-rule-manager.ts
+ */
+export {};

package/clients/ast-grep-types.ts

@@ -0,0 +1,106 @@
+/**
+ * Shared types for ast-grep client, parser, and rule manager.
+ *
+ * Extracted to prevent circular dependencies between:
+ * - ast-grep-client.ts
+ * - ast-grep-parser.ts
+ * - ast-grep-rule-manager.ts
+ */
+
+// =============================================================================
+// RULE DESCRIPTIONS
+// =============================================================================
+
+export interface RuleDescription {
+	id: string;
+	message: string;
+	note?: string;
+	fix?: string; // Suggested fix from rule
+	severity: "error" | "warning" | "info" | "hint";
+	grade?: number;
+}
+
+// =============================================================================
+// MATCHES (from sg-runner)
+// =============================================================================
+
+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;
+}
+
+// =============================================================================
+// DIAGNOSTICS
+// =============================================================================
+
+export interface AstGrepMatch {
+	file: string;
+	range: {
+		start: { line: number; column: number };
+		end: { line: number; column: number };
+	};
+	text: string;
+	replacement?: string;
+	labels?: Array<{
+		range: {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		};
+	}>;
+}
+
+export interface AstGrepDiagnostic {
+	line: number;
+	column: number;
+	endLine: number;
+	endColumn: number;
+	severity: "error" | "warning" | "info" | "hint";
+	message: string;
+	rule: string;
+	ruleDescription?: RuleDescription;
+	file: string;
+	fix?: string;
+	note?: string;
+}
+
+// =============================================================================
+// JSON FORMAT (ast-grep CLI output)
+// =============================================================================
+
+export interface AstGrepJsonDiagnostic {
+	ruleId: string;
+	severity: string;
+	message: string;
+	note?: string;
+	labels: Array<{
+		text: string;
+		range: {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		};
+		file?: string;
+		style: string;
+	}>;
+	// Legacy format support
+	Message?: { text: string };
+	Severity?: string;
+	spans?: Array<{
+		context: string;
+		range: {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		};
+		file: string;
+	}>;
+	name?: string;
+}

package/clients/auto-loop.js

@@ -99,6 +99,15 @@ export function createAutoLoop(pi, config) {
             complete(ctx, "completed - no more work");
             return;
         }
+        // Check if agent is waiting for manual fixes (indicated in the prompt)
+        // If the last message says "When done, run..." we should NOT auto-continue
+        const awaitingManualFix = textContent.includes("When done, run");
+        if (awaitingManualFix) {
+            console.error("[auto-loop] Paused - awaiting agent manual fixes");
+            updateStatus(ctx);
+            // Don't send followUp - wait for agent to manually continue
+            return;
+        }
         // Check max iterations
         state.iteration++;
         if (state.iteration >= state.maxIterations) {
@@ -108,6 +117,7 @@ export function createAutoLoop(pi, config) {
         // Continue to next iteration - send command as follow-up
         updateStatus(ctx);
         const continueMsg = config.continuePrompt || `Run ${config.command} to continue.`;
+        console.error(`[auto-loop] Triggering iteration ${state.iteration + 1}/${state.maxIterations}: ${config.command}`);
         pi.sendUserMessage(`🔄 Auto-loop (${state.iteration + 1}/${state.maxIterations}): ${continueMsg}`, { deliverAs: "followUp" });
     });
     return {

package/clients/auto-loop.ts

@@ -20,7 +20,7 @@ export interface LoopConfig {
 	name: string;
 	/** Maximum iterations before stopping */
 	maxIterations: number;
-	/** Command to run for each iteration (e.g., "/lens-booboo-fix --loop") */
+	/** Command to run for each iteration */
 	command: string;
 	/** Patterns that indicate the loop should exit (e.g., "no more fixable issues") */
 	exitPatterns: RegExp[];
@@ -159,6 +159,16 @@ export function createAutoLoop(
 			return;
 		}
 
+		// Check if agent is waiting for manual fixes (indicated in the prompt)
+		// If the last message says "When done, run..." we should NOT auto-continue
+		const awaitingManualFix = textContent.includes("When done, run");
+		if (awaitingManualFix) {
+			console.error("[auto-loop] Paused - awaiting agent manual fixes");
+			updateStatus(ctx);
+			// Don't send followUp - wait for agent to manually continue
+			return;
+		}
+
 		// Check max iterations
 		state.iteration++;
 		if (state.iteration >= state.maxIterations) {
@@ -170,6 +180,9 @@ export function createAutoLoop(
 		updateStatus(ctx);
 		const continueMsg =
 			config.continuePrompt || `Run ${config.command} to continue.`;
+		console.error(
+			`[auto-loop] Triggering iteration ${state.iteration + 1}/${state.maxIterations}: ${config.command}`,
+		);
 		pi.sendUserMessage(
 			`🔄 Auto-loop (${state.iteration + 1}/${state.maxIterations}): ${continueMsg}`,
 			{ deliverAs: "followUp" },

package/clients/biome-client.js

@@ -7,10 +7,10 @@
  * Requires: npm install @biomejs/biome (or npx @biomejs/biome)
  * Docs: https://biomejs.dev/
  */
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isFileKind } from "./file-kinds.js";
+import { safeSpawn } from "./safe-spawn.js";
 // --- Client ---
 export class BiomeClient {
     constructor(verbose = false) {
@@ -26,10 +26,8 @@ export class BiomeClient {
         if (this.biomeAvailable !== null)
             return this.biomeAvailable;
         // Try npx biome first (works without global install)
-        const result = spawnSync("npx", ["@biomejs/biome", "--version"], {
-            encoding: "utf-8",
+        const result = safeSpawn("npx", ["@biomejs/biome", "--version"], {
             timeout: 10000,
-            shell: true,
         });
         this.biomeAvailable = !result.error && result.status === 0;
         if (this.biomeAvailable) {
@@ -67,16 +65,14 @@ export class BiomeClient {
         if (!absolutePath)
             return [];
         try {
-            const result = spawnSync("npx", [
+            const result = safeSpawn("npx", [
                 "@biomejs/biome",
                 "check",
                 "--reporter=json",
                 "--max-diagnostics=50",
                 absolutePath,
             ], {
-                encoding: "utf-8",
                 timeout: 15000,
-                shell: true,
             });
             // Biome exits 0 on success, 1 on issues found
             const output = result.stdout || "";
@@ -85,7 +81,7 @@ export class BiomeClient {
             return this.parseDiagnostics(output, absolutePath);
         }
         catch (err) {
-            this.log(`Check error: ${err.message}`);
+            this.log(`Check error: ${err instanceof Error ? err.message : String(err)}`);
             return [];
         }
     }
@@ -102,10 +98,8 @@ export class BiomeClient {
             };
         const content = fs.readFileSync(absolutePath, "utf-8");
         try {
-            const result = spawnSync("npx", ["@biomejs/biome", "format", "--write", absolutePath], {
-                encoding: "utf-8",
+            const result = safeSpawn("npx", ["@biomejs/biome", "format", "--write", absolutePath], {
                 timeout: 15000,
-                shell: true,
             });
             if (result.error) {
                 return { success: false, changed: false, error: result.error.message };
@@ -119,7 +113,11 @@ export class BiomeClient {
             return { success: true, changed };
         }
         catch (err) {
-            return { success: false, changed: false, error: err.message };
+            return {
+                success: false,
+                changed: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
         }
     }
     /**
@@ -140,16 +138,14 @@ export class BiomeClient {
             const beforeDiags = this.checkFile(filePath);
             const fixableCount = beforeDiags.filter((d) => d.fixable).length;
             // Apply fixes
-            const result = spawnSync("npx", [
+            const result = safeSpawn("npx", [
                 "@biomejs/biome",
                 "check",
                 "--write",
                 "--unsafe", // Apply unsafe fixes too
                 absolutePath,
             ], {
-                encoding: "utf-8",
                 timeout: 15000,
-                shell: true,
             });
             if (result.error) {
                 return {
@@ -167,7 +163,75 @@ export class BiomeClient {
             return { success: true, changed, fixed: fixableCount };
         }
         catch (err) {
-            return { success: false, changed: false, fixed: 0, error: err.message };
+            return {
+                success: false,
+                changed: false,
+                fixed: 0,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Fix multiple files at once (much faster than file-by-file)
+     */
+    fixFiles(filePaths) {
+        if (!this.isAvailable()) {
+            return {
+                success: false,
+                fixed: 0,
+                changed: 0,
+                error: "Biome not available",
+            };
+        }
+        // Filter to existing files
+        const validFiles = filePaths
+            .map(f => path.resolve(f))
+            .filter(f => fs.existsSync(f));
+        if (validFiles.length === 0) {
+            return { success: true, fixed: 0, changed: 0 };
+        }
+        try {
+            // Count fixable issues before fixing
+            let totalFixable = 0;
+            for (const file of validFiles) {
+                const diags = this.checkFile(file);
+                totalFixable += diags.filter(d => d.fixable).length;
+            }
+            // Run biome once on all files - much faster than npx per file
+            const result = safeSpawn("npx", [
+                "@biomejs/biome",
+                "check",
+                "--write",
+                "--unsafe",
+                ...validFiles,
+            ], {
+                timeout: 60000, // Longer timeout for batch
+            });
+            if (result.error) {
+                return {
+                    success: false,
+                    fixed: 0,
+                    changed: 0,
+                    error: result.error.message,
+                };
+            }
+            // Count how many files actually changed
+            let changedCount = 0;
+            for (const file of validFiles) {
+                // We don't know exactly which files changed without re-reading,
+                // so we report total files processed
+                changedCount++;
+            }
+            this.log(`Fixed ${totalFixable} issue(s) in ${validFiles.length} file(s)`);
+            return { success: true, fixed: totalFixable, changed: changedCount };
+        }
+        catch (err) {
+            return {
+                success: false,
+                fixed: 0,
+                changed: 0,
+                error: err instanceof Error ? err.message : String(err),
+            };
         }
     }
     /**
@@ -213,10 +277,8 @@ export class BiomeClient {
         const content = fs.readFileSync(absolutePath, "utf-8");
         try {
             // Get formatted output without writing
-            const result = spawnSync("npx", ["@biomejs/biome", "format", absolutePath], {
-                encoding: "utf-8",
+            const result = safeSpawn("npx", ["@biomejs/biome", "format", absolutePath], {
                 timeout: 15000,
-                shell: true,
             });
             if (result.error || !result.stdout)
                 return "";