pi-lens 3.6.2 → 3.6.4

package/clients/formatters.js

@@ -1,488 +0,0 @@
-/**
- * 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;
-        // 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;
-            }
-        }
-        // Only enable if the project explicitly uses ruff (config or deps).
-        // Do NOT fall back to "ruff binary is installed" — that would format
-        // projects that never asked for ruff.
-        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 rubocopFormatter = {
-    name: "rubocop",
-    command: ["rubocop", "-a", "--no-color", "$FILE"],
-    extensions: [".rb", ".rake", ".gemspec", ".ru"],
-    async detect(cwd) {
-        // Only run if project has explicit RuboCop config
-        const configs = [".rubocop.yml", ".rubocop.yaml"];
-        const found = await findUp(configs, cwd);
-        if (found.length > 0)
-            return (await which("rubocop")) !== null;
-        // Or rubocop in Gemfile
-        const gemfile = path.join(cwd, "Gemfile");
-        if (await fileExists(gemfile)) {
-            const content = await fs.readFile(gemfile, "utf-8");
-            if (content.includes("rubocop"))
-                return (await which("rubocop")) !== null;
-        }
-        return false;
-    },
-};
-export const standardrbFormatter = {
-    name: "standardrb",
-    command: ["standardrb", "--fix", "$FILE"],
-    extensions: [".rb", ".rake"],
-    async detect(cwd) {
-        // standardrb is only used if explicitly in Gemfile (no config file — it is the config)
-        const gemfile = path.join(cwd, "Gemfile");
-        if (await fileExists(gemfile)) {
-            const content = await fs.readFile(gemfile, "utf-8");
-            if (content.includes("standard"))
-                return (await which("standardrb")) !== null;
-        }
-        return false;
-    },
-};
-export const gleamFormatter = {
-    name: "gleam",
-    command: ["gleam", "format", "$FILE"],
-    extensions: [".gleam"],
-    async detect(cwd) {
-        // Present if gleam.toml exists (any Gleam project)
-        const found = await findUp(["gleam.toml"], cwd);
-        if (found.length > 0)
-            return (await which("gleam")) !== null;
-        return false;
-    },
-};
-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,
-    rubocopFormatter,
-    standardrbFormatter,
-    gleamFormatter,
-];
-// 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 cwd = path.dirname(absolutePath);
-        const contentBefore = await fs.readFile(absolutePath, "utf-8");
-        // Replace $FILE placeholder
-        let cmd = formatter.command.map((c) => c.replace("$FILE", absolutePath));
-        // OPTIMIZATION: Use local biome binary instead of npx if available
-        if (formatter.name === "biome" && cmd[0] === "npx") {
-            const localBiome = path.join(cwd, "node_modules", ".bin", "biome");
-            const localBiomeWin = path.join(cwd, "node_modules", ".bin", "biome.cmd");
-            if (await fileExists(localBiome)) {
-                cmd = [localBiome, ...cmd.slice(2)]; // Replace "npx" "@biomejs/biome" with local path
-            }
-            else if (await fileExists(localBiomeWin)) {
-                cmd = [localBiomeWin, ...cmd.slice(2)];
-            }
-        }
-        // Run formatter
-        const result = safeSpawn(cmd[0], cmd.slice(1), { timeout: 15000, cwd });
-        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);
-}

package/clients/go-client.js

@@ -1,203 +0,0 @@
-/**
- * Go Client for pi-lens
- *
- * Provides Go type checking and linting via gopls and go vet.
- *
- * Requires: gopls (go install golang.org/x/tools/gopls@latest)
- * Docs: https://pkg.go.dev/golang.org/x/tools/gopls
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawn } from "./safe-spawn.js";
-// --- Common install paths ---
-const GO_WINDOWS_PATHS = [
-    "C:\\Program Files\\Go\\bin\\go.exe",
-    "C:\\Go\\bin\\go.exe",
-    "go.exe", // PATH
-];
-const GO_UNIX_PATHS = [
-    "/usr/local/go/bin/go",
-    "/usr/bin/go",
-    "go", // PATH
-];
-// --- Client ---
-export class GoClient {
-    constructor(verbose = false) {
-        this.goplsAvailable = null;
-        this.goAvailable = null;
-        this.goPath = null;
-        this.log = verbose
-            ? (msg) => console.error(`[go] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Find go executable path
-     */
-    findGoPath() {
-        if (this.goPath)
-            return this.goPath;
-        const paths = process.platform === "win32" ? GO_WINDOWS_PATHS : GO_UNIX_PATHS;
-        for (const p of paths) {
-            try {
-                if (p.includes("\\") || p.includes("/")) {
-                    // Absolute path - check if exists
-                    if (fs.existsSync(p)) {
-                        this.goPath = p;
-                        return p;
-                    }
-                }
-                else {
-                    // Relative (PATH) - try running it
-                    const result = safeSpawn(p, ["version"], {
-                        timeout: 3000,
-                    });
-                    if (!result.error && result.status === 0) {
-                        this.goPath = p;
-                        return p;
-                    }
-                }
-            }
-            catch (err) {
-                void err;
-            }
-        }
-        return null;
-    }
-    /**
-     * Check if Go is installed
-     */
-    isGoAvailable() {
-        if (this.goAvailable !== null)
-            return this.goAvailable;
-        this.goAvailable = this.findGoPath() !== null;
-        if (this.goAvailable) {
-            this.log(`Go found: ${this.goPath}`);
-        }
-        return this.goAvailable;
-    }
-    /**
-     * Check if gopls is installed
-     */
-    isGoplsAvailable() {
-        if (this.goplsAvailable !== null)
-            return this.goplsAvailable;
-        const result = safeSpawn("gopls", ["version"], {
-            timeout: 5000,
-        });
-        this.goplsAvailable = !result.error && result.status === 0;
-        if (this.goplsAvailable) {
-            this.log(`gopls found: ${result.stdout?.trim()}`);
-        }
-        return this.goplsAvailable;
-    }
-    /**
-     * Check if a file is a Go file
-     */
-    isGoFile(filePath) {
-        return path.extname(filePath).toLowerCase() === ".go";
-    }
-    /**
-     * Run go vet on a file and return diagnostics
-     */
-    checkFile(filePath) {
-        const goExe = this.findGoPath();
-        if (!goExe)
-            return [];
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
-            return [];
-        const dir = path.dirname(absolutePath);
-        const fileName = path.basename(absolutePath);
-        try {
-            // Run go vet on the specific file
-            const result = safeSpawn(goExe, ["vet", fileName], {
-                timeout: 15000,
-                cwd: dir,
-            });
-            const output = (result.stderr || "") + (result.stdout || "");
-            return this.parseOutput(output, absolutePath);
-        }
-        catch (err) {
-            this.log(`Check error: ${err.message}`);
-            return [];
-        }
-    }
-    /**
-     * Run go build to check for compilation errors
-     */
-    buildCheck(cwd) {
-        if (!this.isGoAvailable())
-            return [];
-        try {
-            const result = safeSpawn("go", ["build", "./..."], {
-                timeout: 30000,
-                cwd,
-            });
-            const output = (result.stderr || "") + (result.stdout || "");
-            return this.parseOutput(output, cwd);
-        }
-        catch (err) {
-            this.log(`Build check error: ${err.message}`);
-            return [];
-        }
-    }
-    /**
-     * Format diagnostics for LLM consumption
-     */
-    formatDiagnostics(diags, maxItems = 10) {
-        if (diags.length === 0)
-            return "";
-        const errors = diags.filter((d) => d.severity === "error");
-        const warnings = diags.filter((d) => d.severity === "warning");
-        let output = `[Go] ${diags.length} issue(s)`;
-        if (errors.length)
-            output += ` — ${errors.length} error(s)`;
-        if (warnings.length)
-            output += ` — ${warnings.length} warning(s)`;
-        output += ":\n";
-        for (const d of diags.slice(0, maxItems)) {
-            const loc = `L${d.line}:${d.column}`;
-            const rule = d.rule ? ` [${d.rule}]` : "";
-            output += `  [${d.severity}] ${loc} ${d.message}${rule}\n`;
-        }
-        if (diags.length > maxItems) {
-            output += `  ... and ${diags.length - maxItems} more\n`;
-        }
-        return output;
-    }
-    // --- Internal ---
-    parseOutput(output, fileOrDir) {
-        if (!output.trim())
-            return [];
-        const diags = [];
-        // Go vet/build output format: "file.go:line:col: message"
-        const pattern = /^(.+?):(\d+):(?:(\d+):)?\s*(?:([^:]+):\s*)?(.+)$/gm;
-        let match;
-        while ((match = pattern.exec(output)) !== null) {
-            const [, file, line, col, rule, message] = match;
-            const lineNum = parseInt(line, 10);
-            const colNum = col ? parseInt(col, 10) : 1;
-            // Filter to the specific file if a file path was provided
-            const absFile = path.isAbsolute(file)
-                ? file
-                : path.resolve(path.dirname(fileOrDir), file);
-            if (path.extname(absFile) !== ".go")
-                continue;
-            const isError = message.includes("undefined") ||
-                message.includes("cannot") ||
-                message.includes("syntax error") ||
-                rule === "compile";
-            diags.push({
-                line: lineNum,
-                column: colNum - 1,
-                endLine: lineNum,
-                endColumn: colNum,
-                severity: isError ? "error" : "warning",
-                message: message.trim().slice(0, 300),
-                rule: rule?.trim(),
-                file: absFile,
-            });
-        }
-        return diags;
-    }
-}