pi-lens 2.2.9 → 3.0.0

package/clients/formatters.js

@@ -0,0 +1,435 @@
+/**
+ * Formatter Definitions for pi-lens
+ *
+ * Auto-detects formatters based on:
+ * - Config files (biome.json, .prettierrc, etc.)
+ * - Dependencies (package.json, requirements.txt, etc.)
+ * - Binary availability (which/where)
+ *
+ * Inspired by OpenCode's formatter.ts pattern
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
+// --- Utility Functions ---
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findUp(targets, startDir, stopDir = path.parse(startDir).root) {
+    const found = [];
+    let currentDir = startDir;
+    while (currentDir !== stopDir) {
+        for (const target of targets) {
+            const checkPath = path.join(currentDir, target);
+            if (await fileExists(checkPath)) {
+                found.push(checkPath);
+            }
+        }
+        const parent = path.dirname(currentDir);
+        if (parent === currentDir)
+            break;
+        currentDir = parent;
+    }
+    return found;
+}
+async function readJson(filePath) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+async function which(command) {
+    const result = safeSpawn(process.platform === "win32" ? "where" : "which", [command], { timeout: 5000 });
+    if (result.error || result.status !== 0)
+        return null;
+    return result.stdout?.trim().split("\n")[0] ?? null;
+}
+// --- Formatter Definitions ---
+export const biomeFormatter = {
+    name: "biome",
+    command: ["npx", "@biomejs/biome", "format", "--write", "$FILE"],
+    extensions: [
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".cjs",
+        ".ts",
+        ".tsx",
+        ".mts",
+        ".cts",
+        ".json",
+        ".jsonc",
+        ".css",
+        ".scss",
+        ".sass",
+        ".vue",
+        ".svelte",
+        ".html",
+        ".htm",
+    ],
+    async detect(cwd) {
+        const configs = ["biome.json", "biome.jsonc"];
+        const found = await findUp(configs, cwd);
+        if (found.length > 0)
+            return true;
+        // Also check if biome is in package.json devDependencies
+        const pkgPath = path.join(cwd, "package.json");
+        if (await fileExists(pkgPath)) {
+            const pkg = (await readJson(pkgPath));
+            if (pkg.devDependencies?.["@biomejs/biome"])
+                return true;
+        }
+        return false;
+    },
+};
+export const prettierFormatter = {
+    name: "prettier",
+    command: ["npx", "prettier", "--write", "$FILE"],
+    extensions: [
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".cjs",
+        ".ts",
+        ".tsx",
+        ".mts",
+        ".cts",
+        ".json",
+        ".jsonc",
+        ".css",
+        ".scss",
+        ".sass",
+        ".less",
+        ".vue",
+        ".svelte",
+        ".html",
+        ".htm",
+        ".md",
+        ".mdx",
+        ".yaml",
+        ".yml",
+        ".graphql",
+        ".gql",
+    ],
+    async detect(cwd) {
+        // Check for prettier config files
+        const configs = [
+            ".prettierrc",
+            ".prettierrc.json",
+            ".prettierrc.yml",
+            ".prettierrc.yaml",
+            ".prettierrc.js",
+            ".prettierrc.cjs",
+            "prettier.config.js",
+            "prettier.config.cjs",
+        ];
+        const found = await findUp(configs, cwd);
+        if (found.length > 0)
+            return true;
+        // Check package.json
+        const pkgPath = path.join(cwd, "package.json");
+        if (await fileExists(pkgPath)) {
+            const pkg = (await readJson(pkgPath));
+            if (pkg.devDependencies?.prettier || pkg.dependencies?.prettier) {
+                return true;
+            }
+            // Also check if "prettier" field exists in package.json
+            if (pkg.prettier !== undefined)
+                return true;
+        }
+        return false;
+    },
+};
+export const ruffFormatter = {
+    name: "ruff",
+    command: ["ruff", "format", "$FILE"],
+    extensions: [".py", ".pyi"],
+    async detect(cwd) {
+        // Check for ruff config
+        const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"];
+        const found = await findUp(configs, cwd);
+        for (const configPath of found) {
+            if (configPath.endsWith("pyproject.toml")) {
+                const content = await fs.readFile(configPath, "utf-8");
+                if (content.includes("[tool.ruff]"))
+                    return true;
+            }
+            else {
+                return true; // ruff.toml or .ruff.toml found
+            }
+        }
+        // Check if ruff in requirements
+        const deps = ["requirements.txt", "pyproject.toml", "Pipfile"];
+        for (const dep of deps) {
+            const depPath = path.join(cwd, dep);
+            if (await fileExists(depPath)) {
+                const content = await fs.readFile(depPath, "utf-8");
+                if (content.includes("ruff"))
+                    return true;
+            }
+        }
+        // Check if ruff binary available and no other Python formatter detected
+        const hasRuff = (await which("ruff")) !== null;
+        if (hasRuff) {
+            // Prefer ruff if no black config found
+            const blackFound = await findUp(["pyproject.toml"], cwd);
+            for (const p of blackFound) {
+                const content = await fs.readFile(p, "utf-8");
+                if (content.includes("[tool.black]"))
+                    return false; // Prefer black if configured
+            }
+            return true;
+        }
+        return false;
+    },
+};
+export const blackFormatter = {
+    name: "black",
+    command: ["black", "$FILE"],
+    extensions: [".py", ".pyi"],
+    async detect(cwd) {
+        // Check for black config in pyproject.toml
+        const configs = ["pyproject.toml"];
+        const found = await findUp(configs, cwd);
+        for (const configPath of found) {
+            const content = await fs.readFile(configPath, "utf-8");
+            if (content.includes("[tool.black]"))
+                return true;
+        }
+        // Check if black in requirements
+        const deps = ["requirements.txt", "pyproject.toml", "Pipfile"];
+        for (const dep of deps) {
+            const depPath = path.join(cwd, dep);
+            if (await fileExists(depPath)) {
+                const content = await fs.readFile(depPath, "utf-8");
+                if (content.toLowerCase().includes("black"))
+                    return true;
+            }
+        }
+        return false;
+    },
+};
+export const gofmtFormatter = {
+    name: "gofmt",
+    command: ["gofmt", "-w", "$FILE"],
+    extensions: [".go"],
+    async detect(_cwd) {
+        return (await which("gofmt")) !== null;
+    },
+};
+export const rustfmtFormatter = {
+    name: "rustfmt",
+    command: ["rustfmt", "$FILE"],
+    extensions: [".rs"],
+    async detect(_cwd) {
+        return (await which("rustfmt")) !== null;
+    },
+};
+export const zigFormatter = {
+    name: "zig",
+    command: ["zig", "fmt", "$FILE"],
+    extensions: [".zig", ".zon"],
+    async detect(_cwd) {
+        return (await which("zig")) !== null;
+    },
+};
+export const dartFormatter = {
+    name: "dart",
+    command: ["dart", "format", "$FILE"],
+    extensions: [".dart"],
+    async detect(_cwd) {
+        return (await which("dart")) !== null;
+    },
+};
+export const shfmtFormatter = {
+    name: "shfmt",
+    command: ["shfmt", "-w", "$FILE"],
+    extensions: [".sh", ".bash"],
+    async detect(_cwd) {
+        return (await which("shfmt")) !== null;
+    },
+};
+export const nixfmtFormatter = {
+    name: "nixfmt",
+    command: ["nixfmt", "$FILE"],
+    extensions: [".nix"],
+    async detect(_cwd) {
+        return (await which("nixfmt")) !== null;
+    },
+};
+export const mixFormatter = {
+    name: "mix",
+    command: ["mix", "format", "$FILE"],
+    extensions: [".ex", ".exs", ".eex", ".heex", ".leex"],
+    async detect(_cwd) {
+        return (await which("mix")) !== null;
+    },
+};
+export const ocamlformatFormatter = {
+    name: "ocamlformat",
+    command: ["ocamlformat", "-i", "$FILE"],
+    extensions: [".ml", ".mli"],
+    async detect(cwd) {
+        const hasBinary = (await which("ocamlformat")) !== null;
+        if (!hasBinary)
+            return false;
+        const configs = [".ocamlformat"];
+        const found = await findUp(configs, cwd);
+        return found.length > 0;
+    },
+};
+export const clangFormatFormatter = {
+    name: "clang-format",
+    command: ["clang-format", "-i", "$FILE"],
+    extensions: [".c", ".cc", ".cpp", ".cxx", ".h", ".hpp", ".ino"],
+    async detect(cwd) {
+        const hasBinary = (await which("clang-format")) !== null;
+        if (!hasBinary)
+            return false;
+        const configs = [".clang-format", "_clang-format"];
+        const found = await findUp(configs, cwd);
+        return found.length > 0;
+    },
+};
+export const ktlintFormatter = {
+    name: "ktlint",
+    command: ["ktlint", "-F", "$FILE"],
+    extensions: [".kt", ".kts"],
+    async detect(_cwd) {
+        return (await which("ktlint")) !== null;
+    },
+};
+export const terraformFormatter = {
+    name: "terraform",
+    command: ["terraform", "fmt", "$FILE"],
+    extensions: [".tf", ".tfvars"],
+    async detect(_cwd) {
+        return (await which("terraform")) !== null;
+    },
+};
+// --- Registry ---
+const ALL_FORMATTERS = [
+    biomeFormatter,
+    prettierFormatter,
+    ruffFormatter,
+    blackFormatter,
+    gofmtFormatter,
+    rustfmtFormatter,
+    zigFormatter,
+    dartFormatter,
+    shfmtFormatter,
+    nixfmtFormatter,
+    mixFormatter,
+    ocamlformatFormatter,
+    clangFormatFormatter,
+    ktlintFormatter,
+    terraformFormatter,
+];
+// Cache for detection results - stores array of enabled formatter names per cwd+ext
+const detectionCache = new Map();
+// --- Public API ---
+export async function getFormattersForFile(filePath, cwd) {
+    const ext = path.extname(filePath).toLowerCase();
+    const cacheKey = `${cwd}:${ext}`;
+    // Check cache
+    let cached = detectionCache.get(cwd);
+    if (!cached) {
+        cached = new Map();
+        detectionCache.set(cwd, cached);
+    }
+    if (cached.has(cacheKey)) {
+        const enabledNames = cached.get(cacheKey);
+        if (!enabledNames || enabledNames.length === 0)
+            return [];
+        // Return cached formatters by name (preserves priority order)
+        return ALL_FORMATTERS.filter((f) => enabledNames.includes(f.name));
+    }
+    // Detect formatters for this extension
+    const matching = ALL_FORMATTERS.filter((f) => f.extensions.includes(ext));
+    const enabled = [];
+    // Check for Biome first (preferred default)
+    const biomeFormatter = matching.find((f) => f.name === "biome");
+    let biomeEnabled = false;
+    if (biomeFormatter) {
+        try {
+            biomeEnabled = await biomeFormatter.detect(cwd);
+            if (biomeEnabled) {
+                enabled.push(biomeFormatter);
+            }
+        }
+        catch (err) {
+            console.error(`[format] Detection failed for ${biomeFormatter.name}:`, err);
+        }
+    }
+    // If Biome is enabled, skip Prettier for overlapping extensions
+    // (Biome is the preferred default, Prettier is fallback)
+    const skipPrettier = biomeEnabled;
+    for (const formatter of matching) {
+        // Skip Biome (already checked above)
+        if (formatter.name === "biome")
+            continue;
+        // Skip Prettier if Biome is enabled (prevents race condition)
+        if (skipPrettier && formatter.name === "prettier")
+            continue;
+        try {
+            const isEnabled = await formatter.detect(cwd);
+            if (isEnabled) {
+                enabled.push(formatter);
+            }
+        }
+        catch (err) {
+            // Detection failed, skip this formatter
+            console.error(`[format] Detection failed for ${formatter.name}:`, err);
+        }
+    }
+    // Store the list of enabled formatter names in cache
+    const enabledNames = enabled.map((f) => f.name);
+    cached.set(cacheKey, enabledNames);
+    return enabled;
+}
+export function clearFormatterCache() {
+    detectionCache.clear();
+}
+export async function formatFile(filePath, formatter) {
+    try {
+        const absolutePath = path.resolve(filePath);
+        const contentBefore = await fs.readFile(absolutePath, "utf-8");
+        // Replace $FILE placeholder
+        const cmd = formatter.command.map((c) => c.replace("$FILE", absolutePath));
+        // Run formatter
+        const result = safeSpawn(cmd[0], cmd.slice(1), { timeout: 15000 });
+        if (result.error) {
+            return {
+                success: false,
+                changed: false,
+                error: result.error.message,
+            };
+        }
+        // Check if content changed
+        const contentAfter = await fs.readFile(absolutePath, "utf-8");
+        const changed = contentBefore !== contentAfter;
+        return {
+            success: true,
+            changed,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            changed: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export function listAllFormatters() {
+    return ALL_FORMATTERS.map((f) => f.name);
+}