pi-lens 2.2.9 → 3.0.0

package/commands/clients/biome-client.js

@@ -0,0 +1,380 @@
+/**
+ * Biome Client for pi-lens
+ *
+ * All-in-one: formatting + linting for JS/TS/JSX/TSX/CSS/JSON
+ * Replaces Prettier with 15-50x faster Rust-based tool.
+ *
+ * Requires: npm install @biomejs/biome (or npx @biomejs/biome)
+ * Docs: https://biomejs.dev/
+ */
+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 {
+    biomeAvailable = null;
+    log;
+    constructor(verbose = false) {
+        this.log = verbose
+            ? (msg) => console.error(`[biome] ${msg}`)
+            : () => { };
+    }
+    /**
+     * Check if biome CLI is available
+     */
+    isAvailable() {
+        if (this.biomeAvailable !== null)
+            return this.biomeAvailable;
+        // Try npx biome first (works without global install)
+        const result = safeSpawn("npx", ["@biomejs/biome", "--version"], {
+            timeout: 10000,
+        });
+        this.biomeAvailable = !result.error && result.status === 0;
+        if (this.biomeAvailable) {
+            const version = result.stdout?.trim() || "unknown";
+            this.log(`Biome found: ${version}`);
+        }
+        else {
+            this.log("Biome not available — install with: npm install -D @biomejs/biome");
+        }
+        return this.biomeAvailable;
+    }
+    /**
+     * Check if a file is supported by Biome
+     */
+    isSupportedFile(filePath) {
+        return isFileKind(filePath, ["jsts", "json", "css"]);
+    }
+    // --- Internal helpers ---
+    /**
+     * Validate path and availability — returns path or null on failure
+     */
+    withValidatedPath(filePath) {
+        if (!this.isAvailable())
+            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 = safeSpawn("npx", [
+                "@biomejs/biome",
+                "check",
+                "--reporter=json",
+                "--max-diagnostics=50",
+                absolutePath,
+            ], {
+                timeout: 15000,
+            });
+            // Biome exits 0 on success, 1 on issues found
+            const output = result.stdout || "";
+            if (!output.trim())
+                return [];
+            return this.parseDiagnostics(output, absolutePath);
+        }
+        catch (err) {
+            this.log(`Check error: ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    /**
+     * Format a file (writes to disk)
+     */
+    formatFile(filePath) {
+        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 = safeSpawn("npx", ["@biomejs/biome", "format", "--write", absolutePath], {
+                timeout: 15000,
+            });
+            if (result.error) {
+                return { success: false, changed: false, error: result.error.message };
+            }
+            // Re-read to see if changed
+            const formatted = fs.readFileSync(absolutePath, "utf-8");
+            const changed = content !== formatted;
+            if (changed) {
+                this.log(`Formatted ${path.basename(filePath)}`);
+            }
+            return { success: true, changed };
+        }
+        catch (err) {
+            return {
+                success: false,
+                changed: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Fix both formatting and linting issues (writes to disk)
+     */
+    fixFile(filePath) {
+        const absolutePath = this.withValidatedPath(filePath);
+        if (!absolutePath)
+            return {
+                success: false,
+                changed: false,
+                fixed: 0,
+                error: this.isAvailable() ? "File not found" : "Biome not available",
+            };
+        const content = fs.readFileSync(absolutePath, "utf-8");
+        try {
+            // First, count issues before fixing
+            const beforeDiags = this.checkFile(filePath);
+            const fixableCount = beforeDiags.filter((d) => d.fixable).length;
+            // Apply fixes
+            const result = safeSpawn("npx", [
+                "@biomejs/biome",
+                "check",
+                "--write",
+                "--unsafe", // Apply unsafe fixes too
+                absolutePath,
+            ], {
+                timeout: 15000,
+            });
+            if (result.error) {
+                return {
+                    success: false,
+                    changed: false,
+                    fixed: 0,
+                    error: result.error.message,
+                };
+            }
+            const fixed = fs.readFileSync(absolutePath, "utf-8");
+            const changed = content !== fixed;
+            if (changed) {
+                this.log(`Fixed ${fixableCount} issue(s) in ${path.basename(filePath)}`);
+            }
+            return { success: true, changed, fixed: fixableCount };
+        }
+        catch (err) {
+            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),
+            };
+        }
+    }
+    /**
+     * Format diagnostics for LLM consumption
+     */
+    formatDiagnostics(diags, _filename) {
+        if (diags.length === 0)
+            return "";
+        const lintIssues = diags.filter((d) => d.category === "lint");
+        const formatIssues = diags.filter((d) => d.category === "format");
+        const errors = diags.filter((d) => d.severity === "error");
+        const fixable = diags.filter((d) => d.fixable);
+        let result = `[Biome] ${diags.length} issue(s)`;
+        if (lintIssues.length)
+            result += ` — ${lintIssues.length} lint`;
+        if (formatIssues.length)
+            result += ` — ${formatIssues.length} format`;
+        if (errors.length)
+            result += ` — ${errors.length} error(s)`;
+        if (fixable.length)
+            result += ` — ${fixable.length} fixable`;
+        result += ":\n";
+        for (const d of diags.slice(0, 15)) {
+            const loc = d.line === d.endLine
+                ? `L${d.line}:${d.column}`
+                : `L${d.line}:${d.column}-L${d.endLine}:${d.endColumn}`;
+            const rule = d.rule ? ` [${d.rule}]` : "";
+            const fix = d.fixable ? " ✓" : "";
+            result += `  ${loc}${rule} ${d.message}${fix}\n`;
+        }
+        if (diags.length > 15) {
+            result += `  ... and ${diags.length - 15} more\n`;
+        }
+        return result;
+    }
+    /**
+     * Generate a diff-like summary of formatting changes
+     */
+    getFormatDiff(filePath) {
+        const absolutePath = this.withValidatedPath(filePath);
+        if (!absolutePath)
+            return "";
+        const content = fs.readFileSync(absolutePath, "utf-8");
+        try {
+            // Get formatted output without writing
+            const result = safeSpawn("npx", ["@biomejs/biome", "format", absolutePath], {
+                timeout: 15000,
+            });
+            if (result.error || !result.stdout)
+                return "";
+            const formatted = result.stdout;
+            if (content === formatted)
+                return "";
+            return this.computeDiff(content, formatted);
+        }
+        catch (err) {
+            void err;
+            return "";
+        }
+    }
+    // --- Internal ---
+    parseDiagnostics(output, filterFile) {
+        try {
+            // Biome JSON output: {"summary": {...}, "diagnostics": [...], ...}
+            const result = JSON.parse(output);
+            const diagnostics = [];
+            const diags = result.diagnostics || [];
+            const filterPath = path.resolve(filterFile);
+            for (const item of diags) {
+                // Filter to our file
+                const itemPath = item.location?.path;
+                if (itemPath && path.resolve(itemPath) !== filterPath)
+                    continue;
+                const loc = item.location || {};
+                const start = loc.start || {};
+                const end = loc.end || start;
+                const isLint = item.category?.startsWith("lint/") || false;
+                const isFormat = item.category === "format";
+                const isAssist = item.category?.startsWith("assist/");
+                // Skip non-lint/format diagnostics (like summaries)
+                if (!isLint && !isFormat && !isAssist)
+                    continue;
+                // Determine if fixable based on category
+                const fixable = isFormat ||
+                    isAssist ||
+                    item.category?.includes("organizeImports") ||
+                    item.message?.includes("fix");
+                diagnostics.push({
+                    line: start.line ?? 1,
+                    column: start.column ?? 1,
+                    endLine: end.line ?? start.line ?? 1,
+                    endColumn: end.column ?? start.column ?? 1,
+                    severity: item.severity || "warning",
+                    message: item.message || "Unknown issue",
+                    rule: isLint ? item.category?.replace("lint/", "") : undefined,
+                    category: isLint ? "lint" : "format",
+                    fixable,
+                });
+            }
+            return diagnostics;
+        }
+        catch (err) {
+            void err;
+            this.log("Failed to parse biome JSON output");
+            return [];
+        }
+    }
+    computeDiff(original, formatted) {
+        const origLines = original.split("\n");
+        const formLines = formatted.split("\n");
+        let changedLines = 0;
+        const changes = [];
+        const maxLen = Math.max(origLines.length, formLines.length);
+        for (let i = 0; i < maxLen; i++) {
+            const orig = origLines[i] ?? "";
+            const form = formLines[i] ?? "";
+            if (orig !== form) {
+                changedLines++;
+                if (changes.length < 5) {
+                    if (orig && form) {
+                        changes.push(`  L${i + 1}: \`${orig.trim()}\` → \`${form.trim()}\``);
+                    }
+                    else if (!form) {
+                        changes.push(`  L${i + 1}: remove line`);
+                    }
+                    else {
+                        changes.push(`  L${i + 1}: add line`);
+                    }
+                }
+            }
+        }
+        let result = `  ${changedLines} line(s) would change`;
+        if (origLines.length !== formLines.length) {
+            result += ` (${origLines.length} → ${formLines.length} lines)`;
+        }
+        result += "\n";
+        for (const c of changes) {
+            result += `${c}\n`;
+        }
+        if (changedLines > 5) {
+            result += `  ... and ${changedLines - 5} more\n`;
+        }
+        return result;
+    }
+}