pi-lens 2.2.9 → 3.0.0

package/clients/fix-scanners.js

@@ -8,9 +8,10 @@
  * - scanBiome: Remaining Biome lint issues
  * - scanSlop: AI slop indicators (high complexity patterns)
  */
-import * as childProcess from "node:child_process";
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
+import { EXCLUDED_DIRS } from "./file-utils.js";
+import { safeSpawn } from "./safe-spawn.js";
 import { shouldIgnoreFile } from "./scan-utils.js";
 const DEBUG_LOG = path.join(process.env.HOME || process.env.USERPROFILE || ".", "pi-lens-debug.log");
 function dbg(msg) {
@@ -18,8 +19,9 @@ function dbg(msg) {
     try {
         nodeFs.appendFileSync(DEBUG_LOG, line);
     }
-    catch {
-        // Ignored
+    catch (err) {
+        // Debug logging failed, silently ignore to avoid recursive errors
+        void err;
     }
 }
 /**
@@ -53,14 +55,12 @@ export function scanDeadCode(knip, targetPath, isTsProject) {
  */
 export function scanAstGrep(targetPath, isTsProject, configPath) {
     const hasSg = nodeFs.existsSync(path.join(targetPath, "node_modules", ".bin", "sg")) ||
-        childProcess.spawnSync("npx", ["sg", "--version"], {
-            encoding: "utf-8",
+        safeSpawn("npx", ["sg", "--version"], {
             timeout: 5000,
-            shell: true,
         }).status === 0;
     if (!hasSg)
         return [];
-    const result = childProcess.spawnSync("npx", [
+    const result = safeSpawn("npx", [
         "sg",
         "scan",
         "--config",
@@ -77,10 +77,7 @@ export function scanAstGrep(targetPath, isTsProject, configPath) {
         ...(isTsProject ? ["--globs", "!**/*.js"] : []),
         targetPath,
     ], {
-        encoding: "utf-8",
         timeout: 30000,
-        shell: true,
-        maxBuffer: 32 * 1024 * 1024,
     });
     const raw = result.stdout?.trim() ?? "";
     const items = raw.startsWith("[")
@@ -125,13 +122,13 @@ export function scanAstGrep(targetPath, isTsProject, configPath) {
 export function scanBiomeIssues(biome, targetPath) {
     if (!biome.isAvailable())
         return [];
-    const checkResult = childProcess.spawnSync("npx", [
+    const checkResult = safeSpawn("npx", [
         "@biomejs/biome",
         "check",
         "--reporter=json",
         "--max-diagnostics=50",
         targetPath,
-    ], { encoding: "utf-8", timeout: 20000, shell: true });
+    ], { timeout: 20000 });
     const remainingBiome = [];
     try {
         const data = JSON.parse(checkResult.stdout ?? "{}");
@@ -165,14 +162,7 @@ export function scanSlop(complexity, targetPath, isTsProject) {
         for (const entry of nodeFs.readdirSync(dir, { withFileTypes: true })) {
             const fullPath = path.join(dir, entry.name);
             if (entry.isDirectory()) {
-                if ([
-                    "node_modules",
-                    ".git",
-                    "dist",
-                    "build",
-                    ".next",
-                    ".pi-lens",
-                ].includes(entry.name))
+                if (EXCLUDED_DIRS.includes(entry.name))
                     continue;
                 scanDir(fullPath);
             }

package/clients/fix-scanners.ts

@@ -14,8 +14,10 @@ import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import type { BiomeClient } from "./biome-client.js";
 import type { ComplexityClient } from "./complexity-client.js";
+import { EXCLUDED_DIRS } from "./file-utils.js";
 import type { JscpdClient } from "./jscpd-client.js";
 import type { KnipClient } from "./knip-client.js";
+import { safeSpawn } from "./safe-spawn.js";
 import { shouldIgnoreFile } from "./scan-utils.js";
 
 export interface DuplicateClone {
@@ -68,8 +70,9 @@ function dbg(msg: string) {
 	const line = `[${new Date().toISOString()}] ${msg}\n`;
 	try {
 		nodeFs.appendFileSync(DEBUG_LOG, line);
-	} catch {
-		// Ignored
+	} catch (err) {
+		// Debug logging failed, silently ignore to avoid recursive errors
+		void err;
 	}
 }
 
@@ -118,15 +121,13 @@ export function scanAstGrep(
 ): AstIssue[] {
 	const hasSg =
 		nodeFs.existsSync(path.join(targetPath, "node_modules", ".bin", "sg")) ||
-		childProcess.spawnSync("npx", ["sg", "--version"], {
-			encoding: "utf-8",
+		safeSpawn("npx", ["sg", "--version"], {
 			timeout: 5000,
-			shell: true,
 		}).status === 0;
 
 	if (!hasSg) return [];
 
-	const result = childProcess.spawnSync(
+	const result = safeSpawn(
 		"npx",
 		[
 			"sg",
@@ -146,10 +147,7 @@ export function scanAstGrep(
 			targetPath,
 		],
 		{
-			encoding: "utf-8",
 			timeout: 30000,
-			shell: true,
-			maxBuffer: 32 * 1024 * 1024,
 		},
 	);
 
@@ -202,7 +200,7 @@ export function scanBiomeIssues(
 ): BiomeIssue[] {
 	if (!biome.isAvailable()) return [];
 
-	const checkResult = childProcess.spawnSync(
+	const checkResult = safeSpawn(
 		"npx",
 		[
 			"@biomejs/biome",
@@ -211,7 +209,7 @@ export function scanBiomeIssues(
 			"--max-diagnostics=50",
 			targetPath,
 		],
-		{ encoding: "utf-8", timeout: 20000, shell: true },
+		{ timeout: 20000 },
 	);
 
 	const remainingBiome: BiomeIssue[] = [];
@@ -251,17 +249,7 @@ export function scanSlop(
 		for (const entry of nodeFs.readdirSync(dir, { withFileTypes: true })) {
 			const fullPath = path.join(dir, entry.name);
 			if (entry.isDirectory()) {
-				if (
-					[
-						"node_modules",
-						".git",
-						"dist",
-						"build",
-						".next",
-						".pi-lens",
-					].includes(entry.name)
-				)
-					continue;
+				if (EXCLUDED_DIRS.includes(entry.name)) continue;
 				scanDir(fullPath);
 			} else if (complexity.isSupportedFile(fullPath)) {
 				const metrics = complexity.analyzeFile(fullPath);

package/clients/format-service.js

@@ -0,0 +1,172 @@
+/**
+ * Format Service for pi-lens
+ *
+ * Concurrent formatter execution using Effect-TS.
+ * Auto-formats files on write with multiple formatters per file.
+ *
+ * Key features:
+ * - Auto-detects formatters based on project config
+ * - Runs multiple formatters concurrently via Effect.all
+ * - FileTime integration for safety
+ * - Multiple formatters per file (e.g., biome + prettier both run)
+ */
+import * as path from "node:path";
+import { Effect, pipe } from "effect";
+import { FileTime } from "./file-time.js";
+import { clearFormatterCache, formatFile, getFormattersForFile, } from "./formatters.js";
+// --- Format Service ---
+export class FormatService {
+    constructor(sessionID, enabled = true) {
+        this.fileTime = new FileTime(sessionID);
+        this.enabled = enabled;
+    }
+    /**
+     * Format a file with all detected formatters
+     * Runs formatters concurrently via Effect-TS
+     */
+    async formatFile(filePath, options = {}) {
+        const absolutePath = path.resolve(filePath);
+        const cwd = path.dirname(absolutePath);
+        // Skip if disabled
+        if (options.skip || !this.enabled) {
+            return {
+                filePath: absolutePath,
+                formatters: [],
+                anyChanged: false,
+                allSucceeded: true,
+            };
+        }
+        // Check if file was modified externally (safety check)
+        if (this.fileTime.hasChanged(absolutePath)) {
+            console.warn(`[format] File ${absolutePath} modified externally, skipping format`);
+            return {
+                filePath: absolutePath,
+                formatters: [],
+                anyChanged: false,
+                allSucceeded: false,
+            };
+        }
+        // Get formatters for this file
+        const formatters = options.formatters
+            ? await this.getFormattersByName(options.formatters)
+            : await getFormattersForFile(absolutePath, cwd);
+        if (formatters.length === 0) {
+            return {
+                filePath: absolutePath,
+                formatters: [],
+                anyChanged: false,
+                allSucceeded: true,
+            };
+        }
+        // Run all formatters concurrently via Effect-TS
+        const results = await this.runFormattersConcurrently(absolutePath, formatters);
+        // Record new file state after formatting
+        this.fileTime.read(absolutePath);
+        // Build summary
+        const anyChanged = results.some((r) => r.changed);
+        const allSucceeded = results.every((r) => r.success);
+        return {
+            filePath: absolutePath,
+            formatters: results.map((r, i) => ({
+                name: formatters[i].name,
+                success: r.success,
+                changed: r.changed,
+                error: r.error,
+            })),
+            anyChanged,
+            allSucceeded,
+        };
+    }
+    /**
+     * Run formatters concurrently using Effect-TS
+     */
+    async runFormattersConcurrently(filePath, formatters) {
+        // Create Effect for each formatter
+        const effects = formatters.map((formatter) => Effect.tryPromise({
+            try: () => formatFile(filePath, formatter),
+            catch: (error) => ({
+                success: false,
+                changed: false,
+                error: error instanceof Error ? error.message : String(error),
+            }),
+        }));
+        // Run all concurrently with Effect.all
+        const program = pipe(Effect.all(effects, { concurrency: "unbounded" }), Effect.timeout(30000), // 30s total timeout for all formatters
+        Effect.catchAll((error) => {
+            console.error("[format] Concurrent formatting failed:", error);
+            return Effect.succeed(formatters.map(() => ({
+                success: false,
+                changed: false,
+                error: "Timeout or concurrent execution failed",
+            })));
+        }));
+        return Effect.runPromise(program);
+    }
+    /**
+     * Get formatters by name (for explicit formatter selection)
+     */
+    async getFormattersByName(names) {
+        const { listAllFormatters, ...formatters } = await import("./formatters.js");
+        const allNames = listAllFormatters();
+        return names
+            .filter((name) => allNames.includes(name))
+            .map((name) => {
+            // Access formatter by name from the exports
+            const key = `${name}Formatter`;
+            return formatters[key];
+        })
+            .filter(Boolean);
+    }
+    /**
+     * Assert file hasn't changed before editing
+     * Throws FileTimeError if file modified externally
+     */
+    assertUnchanged(filePath) {
+        this.fileTime.assert(filePath);
+    }
+    /**
+     * Check if file has changed externally
+     */
+    hasChanged(filePath) {
+        return this.fileTime.hasChanged(filePath);
+    }
+    /**
+     * Record file read (after agent reads file)
+     */
+    recordRead(filePath) {
+        this.fileTime.read(filePath);
+    }
+    /**
+     * Clear detection cache
+     */
+    clearCache() {
+        clearFormatterCache();
+    }
+}
+// --- Singleton Instance ---
+let globalFormatService = null;
+let currentSessionID = null;
+export function getFormatService(sessionID, enabled = true) {
+    // Create new instance if:
+    // 1. No service exists yet
+    // 2. Session ID changed (different session)
+    const shouldCreateNew = !globalFormatService || (sessionID && sessionID !== currentSessionID);
+    if (shouldCreateNew) {
+        globalFormatService = new FormatService(sessionID ?? "default", enabled);
+        currentSessionID = sessionID ?? "default";
+    }
+    return globalFormatService;
+}
+export function resetFormatService() {
+    globalFormatService = null;
+    currentSessionID = null;
+}
+/**
+ * Reset format service and clear all file tracking state.
+ * Use this in tests to ensure complete isolation.
+ */
+export function clearFormatServiceAndFileState() {
+    resetFormatService();
+}
+// Re-export for convenience
+export { clearAllSessions } from "./file-time.js";

package/clients/format-service.ts

@@ -0,0 +1,254 @@
+/**
+ * Format Service for pi-lens
+ *
+ * Concurrent formatter execution using Effect-TS.
+ * Auto-formats files on write with multiple formatters per file.
+ *
+ * Key features:
+ * - Auto-detects formatters based on project config
+ * - Runs multiple formatters concurrently via Effect.all
+ * - FileTime integration for safety
+ * - Multiple formatters per file (e.g., biome + prettier both run)
+ */
+
+import * as path from "node:path";
+import { Effect, pipe } from "effect";
+import { FileTime } from "./file-time.js";
+import {
+	clearFormatterCache,
+	type FormatterInfo,
+	type FormatterResult,
+	formatFile,
+	getFormattersForFile,
+} from "./formatters.js";
+
+// --- Types ---
+
+export interface FormatOptions {
+	/** Skip auto-format even if enabled (manual mode) */
+	skip?: boolean;
+	/** Specific formatters to use (overrides detection) */
+	formatters?: string[];
+}
+
+export interface FormatSummary {
+	filePath: string;
+	formatters: Array<{
+		name: string;
+		success: boolean;
+		changed: boolean;
+		error?: string;
+	}>;
+	anyChanged: boolean;
+	allSucceeded: boolean;
+}
+
+// --- Format Service ---
+
+export class FormatService {
+	private fileTime: FileTime;
+	private enabled: boolean;
+
+	constructor(sessionID: string, enabled: boolean = true) {
+		this.fileTime = new FileTime(sessionID);
+		this.enabled = enabled;
+	}
+
+	/**
+	 * Format a file with all detected formatters
+	 * Runs formatters concurrently via Effect-TS
+	 */
+	async formatFile(
+		filePath: string,
+		options: FormatOptions = {},
+	): Promise<FormatSummary> {
+		const absolutePath = path.resolve(filePath);
+		const cwd = path.dirname(absolutePath);
+
+		// Skip if disabled
+		if (options.skip || !this.enabled) {
+			return {
+				filePath: absolutePath,
+				formatters: [],
+				anyChanged: false,
+				allSucceeded: true,
+			};
+		}
+
+		// Check if file was modified externally (safety check)
+		if (this.fileTime.hasChanged(absolutePath)) {
+			console.warn(
+				`[format] File ${absolutePath} modified externally, skipping format`,
+			);
+			return {
+				filePath: absolutePath,
+				formatters: [],
+				anyChanged: false,
+				allSucceeded: false,
+			};
+		}
+
+		// Get formatters for this file
+		const formatters = options.formatters
+			? await this.getFormattersByName(options.formatters)
+			: await getFormattersForFile(absolutePath, cwd);
+
+		if (formatters.length === 0) {
+			return {
+				filePath: absolutePath,
+				formatters: [],
+				anyChanged: false,
+				allSucceeded: true,
+			};
+		}
+
+		// Run all formatters concurrently via Effect-TS
+		const results = await this.runFormattersConcurrently(
+			absolutePath,
+			formatters,
+		);
+
+		// Record new file state after formatting
+		this.fileTime.read(absolutePath);
+
+		// Build summary
+		const anyChanged = results.some((r) => r.changed);
+		const allSucceeded = results.every((r) => r.success);
+
+		return {
+			filePath: absolutePath,
+			formatters: results.map((r, i) => ({
+				name: formatters[i].name,
+				success: r.success,
+				changed: r.changed,
+				error: r.error,
+			})),
+			anyChanged,
+			allSucceeded,
+		};
+	}
+
+	/**
+	 * Run formatters concurrently using Effect-TS
+	 */
+	private async runFormattersConcurrently(
+		filePath: string,
+		formatters: FormatterInfo[],
+	): Promise<FormatterResult[]> {
+		// Create Effect for each formatter
+		const effects = formatters.map((formatter) =>
+			Effect.tryPromise({
+				try: () => formatFile(filePath, formatter),
+				catch: (error): FormatterResult => ({
+					success: false,
+					changed: false,
+					error: error instanceof Error ? error.message : String(error),
+				}),
+			}),
+		);
+
+		// Run all concurrently with Effect.all
+		const program = pipe(
+			Effect.all(effects, { concurrency: "unbounded" }),
+			Effect.timeout(30000), // 30s total timeout for all formatters
+			Effect.catchAll((error): Effect.Effect<FormatterResult[]> => {
+				console.error("[format] Concurrent formatting failed:", error);
+				return Effect.succeed(
+					formatters.map(() => ({
+						success: false,
+						changed: false,
+						error: "Timeout or concurrent execution failed",
+					})),
+				);
+			}),
+		);
+
+		return Effect.runPromise(program);
+	}
+
+	/**
+	 * Get formatters by name (for explicit formatter selection)
+	 */
+	private async getFormattersByName(names: string[]): Promise<FormatterInfo[]> {
+		const { listAllFormatters, ...formatters } = await import(
+			"./formatters.js"
+		);
+		const allNames = listAllFormatters();
+
+		return names
+			.filter((name) => allNames.includes(name))
+			.map((name) => {
+				// Access formatter by name from the exports
+				const key = `${name}Formatter` as keyof typeof formatters;
+				return formatters[key] as FormatterInfo;
+			})
+			.filter(Boolean);
+	}
+
+	/**
+	 * Assert file hasn't changed before editing
+	 * Throws FileTimeError if file modified externally
+	 */
+	assertUnchanged(filePath: string): void {
+		this.fileTime.assert(filePath);
+	}
+
+	/**
+	 * Check if file has changed externally
+	 */
+	hasChanged(filePath: string): boolean {
+		return this.fileTime.hasChanged(filePath);
+	}
+
+	/**
+	 * Record file read (after agent reads file)
+	 */
+	recordRead(filePath: string): void {
+		this.fileTime.read(filePath);
+	}
+
+	/**
+	 * Clear detection cache
+	 */
+	clearCache(): void {
+		clearFormatterCache();
+	}
+}
+
+// --- Singleton Instance ---
+
+let globalFormatService: FormatService | null = null;
+let currentSessionID: string | null = null;
+
+export function getFormatService(
+	sessionID?: string,
+	enabled: boolean = true,
+): FormatService {
+	// Create new instance if:
+	// 1. No service exists yet
+	// 2. Session ID changed (different session)
+	const shouldCreateNew =
+		!globalFormatService || (sessionID && sessionID !== currentSessionID);
+
+	if (shouldCreateNew) {
+		globalFormatService = new FormatService(sessionID ?? "default", enabled);
+		currentSessionID = sessionID ?? "default";
+	}
+	return globalFormatService!;
+}
+
+export function resetFormatService(): void {
+	globalFormatService = null;
+	currentSessionID = null;
+}
+
+/**
+ * Reset format service and clear all file tracking state.
+ * Use this in tests to ensure complete isolation.
+ */
+export function clearFormatServiceAndFileState(): void {
+	resetFormatService();
+}
+
+// Re-export for convenience
+export { clearAllSessions } from "./file-time.js";