pi-lens 2.2.9 → 3.0.0

package/commands/clients/ruff-client.js

@@ -0,0 +1,297 @@
+/**
+ * Ruff Client for pi-lens
+ *
+ * Fast Python linting and formatting via Ruff CLI.
+ * Replaces flake8, pylint, isort, black, pyupgrade.
+ *
+ * Requires: pip install ruff
+ * Docs: https://docs.astral.sh/ruff/
+ */
+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 RuffClient {
+    ruffAvailable = null;
+    log;
+    constructor(verbose = false) {
+        this.log = verbose
+            ? (msg) => console.error(`[ruff] ${msg}`)
+            : () => { };
+    }
+    /**
+     * Check if ruff CLI is available
+     */
+    isAvailable() {
+        if (this.ruffAvailable !== null)
+            return this.ruffAvailable;
+        try {
+            const result = safeSpawn("ruff", ["--version"], {
+                timeout: 5000,
+            });
+            this.ruffAvailable = !result.error && result.status === 0;
+            if (this.ruffAvailable) {
+                this.log(`Ruff found: ${result.stdout.trim()}`);
+            }
+        }
+        catch (err) {
+            void err;
+            this.ruffAvailable = false;
+        }
+        return this.ruffAvailable;
+    }
+    /**
+     * Check if a file is a Python file
+     */
+    isPythonFile(filePath) {
+        return isFileKind(filePath, "python");
+    }
+    /**
+     * Lint a Python file
+     */
+    checkFile(filePath) {
+        if (!this.isAvailable())
+            return [];
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath))
+            return [];
+        try {
+            const result = safeSpawn("ruff", [
+                "check",
+                "--output-format",
+                "json",
+                "--target-version",
+                "py310",
+                absolutePath,
+            ], {
+                timeout: 10000,
+            });
+            // ruff exits 1 when it finds issues (normal)
+            const output = result.stdout || "";
+            if (!output.trim())
+                return [];
+            return this.parseOutput(output, absolutePath);
+        }
+        catch (err) {
+            this.log(`Check error: ${err.message}`);
+            return [];
+        }
+    }
+    /**
+     * Check if file has formatting issues (ruff format --check)
+     */
+    checkFormatting(filePath) {
+        if (!this.isAvailable())
+            return "";
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath))
+            return "";
+        try {
+            const result = safeSpawn("ruff", ["format", "--check", "--diff", absolutePath], {
+                timeout: 10000,
+            });
+            // ruff format --check exits 1 when changes needed
+            if (result.status === 0)
+                return "";
+            const diff = result.stdout || "";
+            if (!diff.trim())
+                return "";
+            // Count lines that would change
+            const diffLines = diff
+                .split("\n")
+                .filter((l) => l.startsWith("+") || l.startsWith("-")).length;
+            return `[Ruff Format] ${diffLines} line(s) would change — run 'ruff format ${path.basename(filePath)}' to fix`;
+        }
+        catch (err) {
+            void err;
+            return "";
+        } // Intentionally return empty string on diff failure
+    }
+    /**
+     * Auto-fix linting issues (writes to disk)
+     */
+    fixFile(filePath) {
+        if (!this.isAvailable())
+            return {
+                success: false,
+                changed: false,
+                fixed: 0,
+                error: "Ruff not available",
+            };
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath))
+            return {
+                success: false,
+                changed: false,
+                fixed: 0,
+                error: "File not found",
+            };
+        const content = fs.readFileSync(absolutePath, "utf-8");
+        try {
+            const beforeDiags = this.checkFile(filePath);
+            const fixableCount = beforeDiags.filter((d) => d.fixable).length;
+            const result = safeSpawn("ruff", ["check", "--fix", 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.message };
+        }
+    }
+    /**
+     * Fix multiple Python files at once (much faster than file-by-file)
+     */
+    fixFiles(filePaths) {
+        if (!this.isAvailable()) {
+            return {
+                success: false,
+                fixed: 0,
+                changed: 0,
+                error: "Ruff not available",
+            };
+        }
+        // Filter to existing Python files
+        const validFiles = filePaths
+            .map(f => path.resolve(f))
+            .filter(f => fs.existsSync(f) && f.endsWith(".py"));
+        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 ruff once on all files - much faster than per file
+            const result = safeSpawn("ruff", ["check", "--fix", ...validFiles], {
+                timeout: 60000, // Longer timeout for batch
+            });
+            if (result.error) {
+                return {
+                    success: false,
+                    fixed: 0,
+                    changed: 0,
+                    error: result.error.message,
+                };
+            }
+            this.log(`Fixed ${totalFixable} issue(s) in ${validFiles.length} file(s)`);
+            return { success: true, fixed: totalFixable, changed: validFiles.length };
+        }
+        catch (err) {
+            return {
+                success: false,
+                fixed: 0,
+                changed: 0,
+                error: err.message,
+            };
+        }
+    }
+    /**
+     * Format a Python file (writes to disk)
+     */
+    formatFile(filePath) {
+        if (!this.isAvailable())
+            return { success: false, changed: false, error: "Ruff not available" };
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath))
+            return { success: false, changed: false, error: "File not found" };
+        const content = fs.readFileSync(absolutePath, "utf-8");
+        try {
+            const result = safeSpawn("ruff", ["format", absolutePath], {
+                timeout: 10000,
+            });
+            if (result.error) {
+                return { success: false, changed: false, error: result.error.message };
+            }
+            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.message };
+        }
+    }
+    /**
+     * Format diagnostics for LLM consumption
+     */
+    formatDiagnostics(diags) {
+        if (diags.length === 0)
+            return "";
+        const errors = diags.filter((d) => d.severity === "error");
+        const warnings = diags.filter((d) => d.severity === "warning");
+        const fixable = diags.filter((d) => d.fixable);
+        let result = `[Ruff] ${diags.length} issue(s)`;
+        if (errors.length)
+            result += ` — ${errors.length} error(s)`;
+        if (warnings.length)
+            result += ` — ${warnings.length} warning(s)`;
+        if (fixable.length)
+            result += ` — ${fixable.length} auto-fixable`;
+        result += ":\n";
+        for (const d of diags.slice(0, 15)) {
+            const loc = d.line === d.endLine
+                ? `L${d.line}:${d.column}-${d.endColumn}`
+                : `L${d.line}:${d.column}-L${d.endLine}:${d.endColumn}`;
+            const fix = d.fixable ? " [fixable]" : "";
+            result += `  [${d.rule}] ${loc} ${d.message}${fix}\n`;
+        }
+        if (diags.length > 15) {
+            result += `  ... and ${diags.length - 15} more\n`;
+        }
+        if (fixable.length > 0) {
+            result += `\n  Run 'ruff check --fix ${path.basename(diags[0].file)}' to auto-fix ${fixable.length} issue(s)\n`;
+        }
+        return result;
+    }
+    // --- Internal ---
+    parseOutput(output, filterFile) {
+        if (!output.trim())
+            return [];
+        try {
+            const items = JSON.parse(output);
+            const diagnostics = [];
+            for (const item of items) {
+                // Filter to single file if requested
+                if (filterFile && path.resolve(item.filename) !== filterFile)
+                    continue;
+                diagnostics.push({
+                    line: item.location.row - 1, // ruff is 1-indexed
+                    column: item.location.column - 1,
+                    endLine: item.end_location.row - 1,
+                    endColumn: item.end_location.column - 1,
+                    severity: item.code?.startsWith("E") ? "error" : "warning",
+                    message: item.message,
+                    rule: item.code || "unknown",
+                    file: item.filename,
+                    fixable: item.fix !== null,
+                });
+            }
+            return diagnostics;
+        }
+        catch (err) {
+            void err;
+            this.log("Failed to parse ruff JSON output");
+            return [];
+        }
+    }
+}

package/commands/clients/safe-spawn.js

@@ -0,0 +1,88 @@
+/**
+ * Safe cross-platform spawn utilities
+ *
+ * Wraps child_process.spawnSync to handle Windows execution safely
+ * without triggering deprecation warnings.
+ *
+ * Strategy:
+ * - Unix: Use shell: false with normal args
+ * - Windows: Manually construct command string to avoid deprecation warning,
+ *   then use shell: true with no args array
+ */
+import { spawnSync } from "node:child_process";
+/**
+ * Escape an argument for Windows shell execution.
+ * Handles spaces, quotes, and special characters.
+ */
+function escapeWindowsArg(arg) {
+    // If no special characters, return as-is
+    if (!/[\s\"]/.test(arg))
+        return arg;
+    // Escape quotes by doubling them
+    return `"${arg.replace(/"/g, "\"\"")}"`;
+}
+/**
+ * Construct a command string for Windows shell execution.
+ * This avoids the deprecation warning by not passing an args array.
+ */
+function buildWindowsCommand(command, args) {
+    const escapedArgs = args.map(escapeWindowsArg).join(" ");
+    return `${command} ${escapedArgs}`;
+}
+/**
+ * Safely spawn a process cross-platform without shell deprecation warnings.
+ *
+ * On Windows: Uses shell: true but constructs the command string manually
+ * to avoid the deprecation warning about unescaped args.
+ * On Unix: Uses shell: false for normal execution.
+ */
+export function safeSpawn(command, args, options) {
+    if (process.platform === "win32") {
+        // On Windows, construct the full command string and use shell: true
+        // without an args array. This avoids the deprecation warning.
+        const fullCommand = buildWindowsCommand(command, args);
+        const result = spawnSync(fullCommand, {
+            ...options,
+            encoding: "utf-8",
+            shell: true,
+            windowsHide: true,
+        });
+        return {
+            stdout: result.stdout?.toString() || "",
+            stderr: result.stderr?.toString() || "",
+            status: result.status,
+            error: result.error,
+        };
+    }
+    // On Unix, use shell: false (the default) with normal args
+    const result = spawnSync(command, args, {
+        ...options,
+        encoding: "utf-8",
+        shell: false,
+        windowsHide: true,
+    });
+    return {
+        stdout: result.stdout?.toString() || "",
+        stderr: result.stderr?.toString() || "",
+        status: result.status,
+        error: result.error,
+    };
+}
+/**
+ * Check if a command is available in PATH
+ */
+export function isCommandAvailable(command) {
+    const result = safeSpawn(process.platform === "win32" ? "where" : "which", [command], { timeout: 5000 });
+    return result.status === 0;
+}
+/**
+ * Find the full path to a command (npx, node, etc.)
+ */
+export function findCommand(command) {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const result = safeSpawn(finder, [command], { timeout: 5000 });
+    if (result.status !== 0)
+        return null;
+    // Take first line (first match)
+    return result.stdout.trim().split("\n")[0] || null;
+}

package/commands/clients/scan-utils.js

@@ -0,0 +1,83 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { EXCLUDED_DIRS, isTestFile } from "./file-utils.js";
+/**
+ * Common parsing logic for ast-grep JSON output (handles both array and NDJSON).
+ */
+// biome-ignore lint/suspicious/noExplicitAny: ast-grep JSON output is untyped
+export function parseAstGrepJson(raw) {
+    if (!raw)
+        return [];
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("[")) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return [];
+        }
+    }
+    return trimmed.split("\n").flatMap((l) => {
+        try {
+            return [JSON.parse(l)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+/**
+ * Check if a file should be ignored based on project type and common patterns.
+ */
+export function shouldIgnoreFile(filePath, isTsProject) {
+    const relPath = filePath.replace(/\\/g, "/");
+    const _basename = path.basename(relPath);
+    // Ignore compiled JS in TS projects
+    const isJs = relPath.endsWith(".js") ||
+        relPath.endsWith(".mjs") ||
+        relPath.endsWith(".cjs");
+    if (isTsProject && isJs)
+        return true;
+    // Ignore test scripts and common test patterns
+    if (isTestFile(filePath))
+        return true;
+    // Ignore hidden directories and common build outputs
+    if (EXCLUDED_DIRS.some((d) => relPath.includes(`/${d}/`)))
+        return true;
+    return false;
+}
+/**
+ * Recursively find source files in a directory, respecting common excludes.
+ */
+export function getSourceFiles(dir, isTsProject) {
+    const files = [];
+    if (!fs.existsSync(dir))
+        return files;
+    const scan = (d) => {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(d, entry.name);
+            if (entry.isDirectory()) {
+                if (EXCLUDED_DIRS.includes(entry.name))
+                    continue;
+                scan(full);
+            }
+            else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
+                // Skip compiled JS if it's a TS project
+                if (isTsProject &&
+                    entry.name.endsWith(".js") &&
+                    fs.existsSync(full.replace(/\.js$/, ".ts")))
+                    continue;
+                files.push(full);
+            }
+        }
+    };
+    scan(dir);
+    return files;
+}

package/commands/clients/sg-runner.js

@@ -0,0 +1,190 @@
+/**
+ * SgRunner - encapsulates ast-grep subprocess management
+ *
+ * Extracted from AstGrepClient to simplify the main client.
+ * Handles: spawn, spawnSync, temp dir management, JSON parsing.
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
+export class SgRunner {
+    log;
+    constructor(verbose = false) {
+        this.log = verbose
+            ? (msg) => console.error(`[sg-runner] ${msg}`)
+            : () => { };
+    }
+    /**
+     * Check if ast-grep CLI is available
+     */
+    isAvailable() {
+        const result = safeSpawn("npx", ["sg", "--version"], {
+            timeout: 10000,
+        });
+        return !result.error && result.status === 0;
+    }
+    /**
+     * Run ast-grep asynchronously, return parsed matches
+     */
+    async exec(args) {
+        return new Promise((resolve) => {
+            // On Windows, construct full command string to avoid deprecation warning
+            const useShell = process.platform === "win32";
+            const fullCommand = useShell
+                ? `npx sg ${args.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}`
+                : undefined;
+            const proc = fullCommand
+                ? spawn(fullCommand, { stdio: ["ignore", "pipe", "pipe"], shell: true })
+                : spawn("npx", ["sg", ...args], { stdio: ["ignore", "pipe", "pipe"] });
+            let stdout = "";
+            let stderr = "";
+            proc.stdout.on("data", (data) => (stdout += data.toString()));
+            proc.stderr.on("data", (data) => (stderr += data.toString()));
+            proc.on("error", (err) => {
+                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) => {
+                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 {
+                    resolve({ matches: [], error: "Failed to parse output" });
+                }
+            });
+        });
+    }
+    /**
+     * Run ast-grep synchronously (for simple scans)
+     */
+    execSync(args) {
+        const result = safeSpawn("npx", ["sg", ...args], {
+            timeout: 30000,
+        });
+        if (result.error) {
+            return { output: "", error: result.error.message };
+        }
+        const output = result.stdout || result.stderr || "";
+        return { output };
+    }
+    /**
+     * Run a temporary rule scan (creates temp dir with rule file)
+     */
+    tempScan(dir, ruleId, ruleYaml, timeout = 30000) {
+        const tmpDir = 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 = safeSpawn("npx", ["sg", "scan", "--config", configFile, "--json", dir], { timeout });
+            const output = result.stdout || result.stderr || "";
+            if (!output.trim())
+                return [];
+            const items = JSON.parse(output);
+            return Array.isArray(items) ? items : [items];
+        }
+        catch {
+            return [];
+        }
+        finally {
+            try {
+                fs.rmSync(sessionDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                this.log(`Cleanup failed: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * Run a rule file scan (temporary config approach) - alias for tempScan
+     */
+    scanWithRule(ruleYaml, dir, timeout = 30000) {
+        const sessionDir = path.join(os.tmpdir(), `sg-scan-${Date.now()}`);
+        const rulesSubdir = path.join(sessionDir, "rules");
+        const configFile = path.join(sessionDir, ".sgconfig.yml");
+        const ruleFile = path.join(rulesSubdir, "rule.yml");
+        try {
+            fs.mkdirSync(rulesSubdir, { recursive: true });
+            fs.writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
+            fs.writeFileSync(ruleFile, ruleYaml);
+            const result = safeSpawn("npx", ["sg", "scan", "--config", configFile, "--json", dir], { timeout });
+            const output = result.stdout || result.stderr || "";
+            if (!output.trim())
+                return [];
+            const items = JSON.parse(output);
+            return Array.isArray(items) ? items : [items];
+        }
+        catch {
+            return [];
+        }
+        finally {
+            try {
+                fs.rmSync(sessionDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                this.log(`Cleanup failed: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * Format matches for display
+     */
+    formatMatches(matches, isDryRun = false, maxItems = 50, showModeIndicator = false) {
+        if (matches.length === 0) {
+            if (showModeIndicator) {
+                return isDryRun
+                    ? "[DRY-RUN] No matches found."
+                    : "[APPLIED] No changes made (no matches found).";
+            }
+            return "No matches found";
+        }
+        const shown = matches.slice(0, maxItems);
+        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 > maxItems) {
+            lines.unshift(`Found ${matches.length} matches (showing first ${maxItems}):`);
+        }
+        if (showModeIndicator) {
+            const prefix = isDryRun ? "[DRY-RUN]" : "[APPLIED]";
+            const suffix = isDryRun
+                ? "\n\n(Dry run — use apply=true to apply changes)"
+                : "";
+            return `${prefix} ${matches.length} replacement(s):\n\n${lines.join("\n")}${suffix}`;
+        }
+        return lines.join("\n");
+    }
+}

package/commands/clients/types.js

@@ -0,0 +1,11 @@
+/**
+ * LSP Types - Core types for the pi-local LSP client
+ * Simplified from the full LSP spec to what we actually need
+ */
+export var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 1] = "Error";
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 2] = "Warning";
+    DiagnosticSeverity[DiagnosticSeverity["Information"] = 3] = "Information";
+    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 4] = "Hint";
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));