pi-lens 2.0.37 → 2.0.39

package/clients/ast-grep-client.ts

@@ -8,11 +8,19 @@
  * Rules: ./rules/ directory
  */
 
-import { spawn, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 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 { SgRunner, type SgMatch } from "./sg-runner.js";
+
+const getExtensionDir = () => {
+	if (typeof __dirname !== "undefined") {
+		return __dirname;
+	}
+	return ".";
+};
 
 // --- Types ---
 
@@ -54,19 +62,15 @@ export class AstGrepClient {
 	private ruleDir: string;
 	private log: (msg: string) => void;
 	private ruleManager: AstGrepRuleManager;
+	private runner: SgRunner;
 
 	constructor(ruleDir?: string, verbose = false) {
-		this.ruleDir =
-			ruleDir ||
-			path.join(
-				typeof __dirname !== "undefined" ? __dirname : ".",
-				"..",
-				"rules",
-			);
+		this.ruleDir = ruleDir || path.join(process.cwd(), "rules");
 		this.log = verbose
 			? (msg: string) => console.error(`[ast-grep] ${msg}`)
 			: () => {};
 		this.ruleManager = new AstGrepRuleManager(this.ruleDir, this.log);
+		this.runner = new SgRunner(verbose);
 	}
 
 	/**
@@ -74,18 +78,10 @@ export class AstGrepClient {
 	 */
 	isAvailable(): boolean {
 		if (this.available !== null) return this.available;
-
-		const result = spawnSync("npx", ["sg", "--version"], {
-			encoding: "utf-8",
-			timeout: 10000,
-			shell: true,
-		});
-
-		this.available = !result.error && result.status === 0;
+		this.available = this.runner.isAvailable();
 		if (this.available) {
 			this.log("ast-grep available");
 		}
-
 		return this.available;
 	}
 
@@ -97,7 +93,7 @@ export class AstGrepClient {
 		lang: string,
 		paths: string[],
 	): Promise<{ matches: AstGrepMatch[]; error?: string }> {
-		return this.runSg([
+		return this.runner.exec([
 			"run",
 			"-p",
 			pattern,
@@ -131,7 +127,7 @@ export class AstGrepClient {
 		if (apply) args.push("--update-all");
 		args.push(...paths);
 
-		const result = await this.runSg(args);
+		const result = await this.runner.exec(args);
 		return { matches: result.matches, applied: apply, error: result.error };
 	}
 
@@ -145,44 +141,7 @@ export class AstGrepClient {
 		timeout = 30000,
 	): any[] {
 		if (!this.isAvailable()) return [];
-
-		const tmpDir = require("node: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 (err) {
-			void err;
-			return [];
-		} finally {
-			try {
-				fs.rmSync(sessionDir, { recursive: true, force: true });
-			} catch (err) {
-				void err;
-			}
-		}
+		return this.runner.tempScan(dir, ruleId, ruleYaml, timeout);
 	}
 
 	/**
@@ -215,42 +174,30 @@ message: found
 		pattern: string;
 		functions: Array<{ name: string; file: string; line: number }>;
 	}> {
-		const normalized = new Map<
-			string,
-			Array<{ name: string; file: string; line: number }>
-		>();
+		const grouped = new Map<string, Array<{ name: string; file: string; line: number }>>();
 
 		for (const item of matches) {
-			const text = item.text || "";
-			const nameMatch = text.match(/function\s+(\w+)/);
-			if (!nameMatch?.[1]) continue;
+			const name = this.extractFunctionName(item.text);
+			if (!name) continue;
 
-			const signature = this.normalizeFunction(text);
+			const signature = this.normalizeFunction(item.text);
+			const line = (item.range?.start?.line || item.labels?.[0]?.range?.start?.line || 0) + 1;
 
-			if (!normalized.has(signature)) {
-				normalized.set(signature, []);
-			}
-
-			const line =
-				item.range?.start?.line || item.labels?.[0]?.range?.start?.line || 0;
-			normalized.get(signature)?.push({
-				name: nameMatch[1],
-				file: item.file,
-				line: line + 1,
-			});
+			const group = grouped.get(signature) ?? [];
+			group.push({ name, file: item.file, line });
+			grouped.set(signature, group);
 		}
 
-		const result_groups: Array<{
-			pattern: string;
-			functions: Array<{ name: string; file: string; line: number }>;
-		}> = [];
-		for (const [pattern, functions] of normalized) {
-			if (functions.length > 1) {
-				result_groups.push({ pattern, functions });
-			}
-		}
+		return Array.from(grouped.entries())
+			.filter(([_, functions]) => functions.length > 1)
+			.map(([pattern, functions]) => ({ pattern, functions }));
+	}
 
-		return result_groups;
+	/**
+	 * Extract function name from match text
+	 */
+	private extractFunctionName(text: string): string | null {
+		return text.match(/function\s+(\w+)/)?.[1] ?? null;
 	}
 
 	private normalizeFunction(text: string): string {
@@ -305,71 +252,8 @@ message: found
 		return exports;
 	}
 
-	private runSg(
-		args: string[],
-	): Promise<{ matches: AstGrepMatch[]; error?: string }> {
-		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 (err) {
-					void err;
-					resolve({ matches: [], error: "Failed to parse output" });
-				}
-			});
-		});
-	}
-
 	formatMatches(matches: AstGrepMatch[], isDryRun = false): string {
-		if (matches.length === 0) return "No matches found";
-		const MAX = 50;
-		const shown = matches.slice(0, MAX);
-		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 > MAX)
-			lines.unshift(`Found ${matches.length} matches (showing first ${MAX}):`);
-		return lines.join("\n");
+		return this.runner.formatMatches(matches as SgMatch[], isDryRun);
 	}
 
 	/**

package/clients/auto-loop.js

@@ -0,0 +1,117 @@
+/**
+ * Auto-loop engine for pi-lens fix and refactor commands.
+ *
+ * Provides automatic iteration without requiring the user to manually
+ * re-run the command each time. Uses pi's event system (agent_end)
+ * to trigger the next iteration automatically.
+ *
+ * IMPORTANT: Must be initialized at extension load time (in index.ts),
+ * not lazily when the command is called. Event handlers need to be
+ * registered early to catch agent_end events.
+ */
+export function createAutoLoop(pi, config) {
+    let state = {
+        active: false,
+        iteration: 0,
+        maxIterations: config.maxIterations,
+    };
+    const updateStatus = (ctx) => {
+        if (state.active) {
+            ctx.ui.setStatus(`loop-${config.name}`, `${config.name} (${state.iteration + 1}/${state.maxIterations})`);
+        }
+        else {
+            ctx.ui.setStatus(`loop-${config.name}`, undefined);
+        }
+    };
+    const stop = (ctx, reason) => {
+        const wasActive = state.active;
+        state = { active: false, iteration: 0, maxIterations: config.maxIterations };
+        updateStatus(ctx);
+        if (wasActive) {
+            ctx.ui.notify(`✅ ${config.name} loop ${reason}`, "info");
+        }
+    };
+    const complete = (ctx, reason) => {
+        stop(ctx, reason);
+    };
+    const start = (ctx) => {
+        if (state.active) {
+            ctx.ui.notify(`${config.name} loop is already running`, "warning");
+            return;
+        }
+        state = {
+            active: true,
+            iteration: 0,
+            maxIterations: config.maxIterations,
+        };
+        updateStatus(ctx);
+        ctx.ui.notify(`🔄 Starting ${config.name} auto-loop (max ${state.maxIterations} iterations)...`, "info");
+    };
+    const getState = () => ({ ...state });
+    // --- Event Handlers (registered at module load time) ---
+    // Handle user interruption (any manual input stops the loop)
+    pi.on("input", async (event, ctx) => {
+        if (!ctx.hasUI)
+            return { action: "continue" };
+        if (!state.active)
+            return { action: "continue" };
+        // User typed something manually → stop the auto-loop
+        if (event.source === "interactive") {
+            stop(ctx, "stopped (user interrupted)");
+        }
+        return { action: "continue" };
+    });
+    // Handle end of agent turn → check if we should continue
+    pi.on("agent_end", async (event, ctx) => {
+        if (!ctx.hasUI)
+            return;
+        if (!state.active)
+            return;
+        const assistantMessages = event.messages.filter((m) => m.role === "assistant");
+        const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
+        if (!lastAssistantMessage) {
+            stop(ctx, "stopped (no response)");
+            return;
+        }
+        const textContent = lastAssistantMessage.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text)
+            .join("\n");
+        if (!textContent.trim()) {
+            stop(ctx, "stopped (empty response)");
+            return;
+        }
+        // Check for completion patterns (explicit success)
+        if (config.completionPatterns) {
+            const hasCompletion = config.completionPatterns.some((p) => p.test(textContent));
+            if (hasCompletion) {
+                complete(ctx, "completed successfully");
+                return;
+            }
+        }
+        // Check for exit patterns (could be success or stopped)
+        const hasExit = config.exitPatterns.some((p) => p.test(textContent));
+        if (hasExit) {
+            complete(ctx, "completed - no more work");
+            return;
+        }
+        // Check max iterations
+        state.iteration++;
+        if (state.iteration >= state.maxIterations) {
+            stop(ctx, `stopped (max iterations ${state.maxIterations} reached)`);
+            return;
+        }
+        // Continue to next iteration - send command as follow-up
+        updateStatus(ctx);
+        const continueMsg = config.continuePrompt || `Run ${config.command} to continue.`;
+        pi.sendUserMessage(`🔄 Auto-loop (${state.iteration + 1}/${state.maxIterations}): ${continueMsg}`, { deliverAs: "followUp" });
+    });
+    return {
+        start,
+        stop,
+        getState,
+        setMaxIterations: (n) => {
+            state.maxIterations = n;
+        },
+    };
+}

package/clients/auto-loop.ts

@@ -0,0 +1,171 @@
+/**
+ * Auto-loop engine for pi-lens fix and refactor commands.
+ *
+ * Provides automatic iteration without requiring the user to manually
+ * re-run the command each time. Uses pi's event system (agent_end)
+ * to trigger the next iteration automatically.
+ *
+ * IMPORTANT: Must be initialized at extension load time (in index.ts),
+ * not lazily when the command is called. Event handlers need to be
+ * registered early to catch agent_end events.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+export interface LoopConfig {
+	/** Unique identifier for this loop instance (e.g., "fix", "refactor") */
+	name: string;
+	/** Maximum iterations before stopping */
+	maxIterations: number;
+	/** Command to run for each iteration (e.g., "/lens-booboo-fix --loop") */
+	command: string;
+	/** Patterns that indicate the loop should exit (e.g., "no more fixable issues") */
+	exitPatterns: RegExp[];
+	/** Patterns that indicate completion with success */
+	completionPatterns?: RegExp[];
+	/** Additional text to include when prompting for next iteration */
+	continuePrompt?: string;
+}
+
+export interface LoopState {
+	active: boolean;
+	iteration: number;
+	maxIterations: number;
+}
+
+export function createAutoLoop(pi: ExtensionAPI, config: LoopConfig): {
+	start: (ctx: ExtensionContext) => void;
+	stop: (ctx: ExtensionContext, reason: string) => void;
+	getState: () => LoopState;
+	setMaxIterations: (n: number) => void;
+} {
+	let state: LoopState = {
+		active: false,
+		iteration: 0,
+		maxIterations: config.maxIterations,
+	};
+
+	const updateStatus = (ctx: ExtensionContext) => {
+		if (state.active) {
+			ctx.ui.setStatus(
+				`loop-${config.name}`,
+				`${config.name} (${state.iteration + 1}/${state.maxIterations})`,
+			);
+		} else {
+			ctx.ui.setStatus(`loop-${config.name}`, undefined);
+		}
+	};
+
+	const stop = (ctx: ExtensionContext, reason: string) => {
+		const wasActive = state.active;
+		state = { active: false, iteration: 0, maxIterations: config.maxIterations };
+		updateStatus(ctx);
+		if (wasActive) {
+			ctx.ui.notify(`✅ ${config.name} loop ${reason}`, "info");
+		}
+	};
+
+	const complete = (ctx: ExtensionContext, reason: string) => {
+		stop(ctx, reason);
+	};
+
+	const start = (ctx: ExtensionContext) => {
+		if (state.active) {
+			ctx.ui.notify(`${config.name} loop is already running`, "warning");
+			return;
+		}
+
+		state = {
+			active: true,
+			iteration: 0,
+			maxIterations: config.maxIterations,
+		};
+
+		updateStatus(ctx);
+		ctx.ui.notify(
+			`🔄 Starting ${config.name} auto-loop (max ${state.maxIterations} iterations)...`,
+			"info",
+		);
+	};
+
+	const getState = (): LoopState => ({ ...state });
+
+	// --- Event Handlers (registered at module load time) ---
+
+	// Handle user interruption (any manual input stops the loop)
+	pi.on("input", async (event, ctx) => {
+		if (!ctx.hasUI) return { action: "continue" as const };
+		if (!state.active) return { action: "continue" as const };
+
+		// User typed something manually → stop the auto-loop
+		if (event.source === "interactive") {
+			stop(ctx, "stopped (user interrupted)");
+		}
+
+		return { action: "continue" as const };
+	});
+
+	// Handle end of agent turn → check if we should continue
+	pi.on("agent_end", async (event, ctx) => {
+		if (!ctx.hasUI) return;
+		if (!state.active) return;
+
+		const assistantMessages = event.messages.filter((m) => m.role === "assistant");
+		const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
+
+		if (!lastAssistantMessage) {
+			stop(ctx, "stopped (no response)");
+			return;
+		}
+
+		const textContent = lastAssistantMessage.content
+			.filter((c): c is { type: "text"; text: string } => c.type === "text")
+			.map((c) => c.text)
+			.join("\n");
+
+		if (!textContent.trim()) {
+			stop(ctx, "stopped (empty response)");
+			return;
+		}
+
+		// Check for completion patterns (explicit success)
+		if (config.completionPatterns) {
+			const hasCompletion = config.completionPatterns.some((p) => p.test(textContent));
+			if (hasCompletion) {
+				complete(ctx, "completed successfully");
+				return;
+			}
+		}
+
+		// Check for exit patterns (could be success or stopped)
+		const hasExit = config.exitPatterns.some((p) => p.test(textContent));
+		if (hasExit) {
+			complete(ctx, "completed - no more work");
+			return;
+		}
+
+		// Check max iterations
+		state.iteration++;
+		if (state.iteration >= state.maxIterations) {
+			stop(ctx, `stopped (max iterations ${state.maxIterations} reached)`);
+			return;
+		}
+
+		// Continue to next iteration - send command as follow-up
+		updateStatus(ctx);
+		const continueMsg = config.continuePrompt || `Run ${config.command} to continue.`;
+		pi.sendUserMessage(
+			`🔄 Auto-loop (${state.iteration + 1}/${state.maxIterations}): ${continueMsg}`,
+			{ deliverAs: "followUp" },
+		);
+	});
+
+	return {
+		start,
+		stop,
+		getState,
+		setMaxIterations: (n: number) => {
+			state.maxIterations = n;
+		},
+	};
+}

package/clients/biome-client.js

@@ -56,14 +56,24 @@ export class BiomeClient {
             ".cjs",
         ].includes(ext);
     }
+    // --- Internal helpers ---
     /**
-     * Run biome check (format + lint) without fixing — returns diagnostics
+     * Validate path and availability — returns path or null on failure
      */
-    checkFile(filePath) {
+    withValidatedPath(filePath) {
         if (!this.isAvailable())
-            return [];
+            return null;
         const absolutePath = path.resolve(filePath);
         if (!fs.existsSync(absolutePath))
+            return null;
+        return absolutePath;
+    }
+    /**
+     * Run biome check (format + lint) without fixing — returns diagnostics
+     */
+    checkFile(filePath) {
+        const absolutePath = this.withValidatedPath(filePath);
+        if (!absolutePath)
             return [];
         try {
             const result = spawnSync("npx", [
@@ -92,11 +102,13 @@ export class BiomeClient {
      * Format a file (writes to disk)
      */
     formatFile(filePath) {
-        if (!this.isAvailable())
-            return { success: false, changed: false, error: "Biome not available" };
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
-            return { success: false, changed: false, error: "File not found" };
+        const absolutePath = this.withValidatedPath(filePath);
+        if (!absolutePath)
+            return {
+                success: false,
+                changed: false,
+                error: this.isAvailable() ? "File not found" : "Biome not available",
+            };
         const content = fs.readFileSync(absolutePath, "utf-8");
         try {
             const result = spawnSync("npx", ["@biomejs/biome", "format", "--write", absolutePath], {
@@ -123,20 +135,13 @@ export class BiomeClient {
      * Fix both formatting and linting issues (writes to disk)
      */
     fixFile(filePath) {
-        if (!this.isAvailable())
+        const absolutePath = this.withValidatedPath(filePath);
+        if (!absolutePath)
             return {
                 success: false,
                 changed: false,
                 fixed: 0,
-                error: "Biome not available",
-            };
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
-            return {
-                success: false,
-                changed: false,
-                fixed: 0,
-                error: "File not found",
+                error: this.isAvailable() ? "File not found" : "Biome not available",
             };
         const content = fs.readFileSync(absolutePath, "utf-8");
         try {
@@ -211,10 +216,8 @@ export class BiomeClient {
      * Generate a diff-like summary of formatting changes
      */
     getFormatDiff(filePath) {
-        if (!this.isAvailable())
-            return "";
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
+        const absolutePath = this.withValidatedPath(filePath);
+        if (!absolutePath)
             return "";
         const content = fs.readFileSync(absolutePath, "utf-8");
         try {