pi-lens 3.6.2 → 3.6.4

package/clients/ast-grep-rule-manager.js

@@ -1,89 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-export class AstGrepRuleManager {
-    constructor(ruleDir, log) {
-        this.ruleDir = ruleDir;
-        this.log = log;
-        this.ruleDescriptions = null;
-    }
-    loadRuleDescriptions() {
-        if (this.ruleDescriptions !== null)
-            return this.ruleDescriptions;
-        const descriptions = new Map();
-        const possiblePaths = [
-            path.join(this.ruleDir, "ast-grep-rules", "rules"),
-            path.join(this.ruleDir, "rules"),
-            this.ruleDir,
-        ];
-        const rulesPath = possiblePaths.find((p) => fs.existsSync(p));
-        if (!rulesPath) {
-            this.log(`Rule descriptions: no rules directory found in ${possiblePaths.join(", ")}`);
-            this.ruleDescriptions = descriptions;
-            return descriptions;
-        }
-        try {
-            const files = fs.readdirSync(rulesPath).filter((f) => f.endsWith(".yml"));
-            this.log(`Loaded ${files.length} rule descriptions from ${rulesPath}`);
-            for (const file of files) {
-                const filePath = path.join(rulesPath, file);
-                const content = fs.readFileSync(filePath, "utf-8");
-                const rule = this.parseRuleYaml(content);
-                if (rule) {
-                    descriptions.set(rule.id, rule);
-                }
-            }
-        }
-        catch (err) {
-            this.log(`Failed to load rule descriptions: ${err.message}`);
-        }
-        this.ruleDescriptions = descriptions;
-        return descriptions;
-    }
-    parseRuleYaml(content) {
-        const result = {};
-        const idMatch = content.match(/^id:\s*(.+)$/m);
-        if (idMatch)
-            result.id = idMatch[1].trim();
-        const msgMatch = content.match(/^message:\s*"([^"]+)"/m) ||
-            content.match(/^message:\s*'([^']+)'/m) ||
-            content.match(/^message:\s*(.+)$/m);
-        if (msgMatch)
-            result.message = (msgMatch[3] || msgMatch[2] || msgMatch[1]).trim();
-        const noteMatch = content.match(/^note:\s*\|([\s\S]*?)(?=^\w|\n\n|\nrule:)/m);
-        if (noteMatch) {
-            result.note = noteMatch[1]
-                .split("\n")
-                .map((line) => line.trim())
-                .filter((line) => line.length > 0)
-                .join(" ");
-        }
-        const sevMatch = content.match(/^severity:\s*(.+)$/m);
-        if (sevMatch)
-            result.severity = this.mapSeverity(sevMatch[1].trim());
-        const gradeMatch = content.match(/Grade\s+(\d+\.\d+)/i);
-        if (gradeMatch)
-            result.grade = parseFloat(gradeMatch[1]);
-        const fixMatch = content.match(/^fix:\s*\|?([\s\S]*?)(?=^\w|^rule:|Z)/m);
-        if (fixMatch) {
-            result.fix = fixMatch[1]
-                .split("\n")
-                .map((line) => line.replace(/^\s*\|?\s*/, ""))
-                .filter((line) => line.length > 0)
-                .join("\n");
-        }
-        if (result.id && result.message) {
-            return result;
-        }
-        return null;
-    }
-    mapSeverity(severity) {
-        const lower = severity.toLowerCase();
-        if (lower === "error")
-            return "error";
-        if (lower === "warning")
-            return "warning";
-        if (lower === "info")
-            return "info";
-        return "hint";
-    }
-}

package/clients/ast-grep-types.js

@@ -1,9 +0,0 @@
-/**
- * Shared types for ast-grep client, parser, and rule manager.
- *
- * Extracted to prevent circular dependencies between:
- * - ast-grep-client.ts
- * - ast-grep-parser.ts
- * - ast-grep-rule-manager.ts
- */
-export {};

package/clients/auto-loop.js

@@ -1,131 +0,0 @@
-/**
- * Auto-loop engine for pi-lens fix and refactor commands.
- *
- * Provides automatic iteration without requiring the user to manually
- * re-run the command each time. Uses pi's event system (agent_end)
- * to trigger the next iteration automatically.
- *
- * IMPORTANT: Must be initialized at extension load time (in index.ts),
- * not lazily when the command is called. Event handlers need to be
- * registered early to catch agent_end events.
- */
-export function createAutoLoop(pi, config) {
-    let state = {
-        active: false,
-        iteration: 0,
-        maxIterations: config.maxIterations,
-    };
-    const updateStatus = (ctx) => {
-        if (state.active) {
-            ctx.ui.setStatus(`loop-${config.name}`, `${config.name} (${state.iteration + 1}/${state.maxIterations})`);
-        }
-        else {
-            ctx.ui.setStatus(`loop-${config.name}`, undefined);
-        }
-    };
-    const stop = (ctx, reason) => {
-        const wasActive = state.active;
-        state = {
-            active: false,
-            iteration: 0,
-            maxIterations: config.maxIterations,
-        };
-        updateStatus(ctx);
-        if (wasActive) {
-            ctx.ui.notify(`✅ ${config.name} loop ${reason}`, "info");
-        }
-    };
-    const complete = (ctx, reason) => {
-        stop(ctx, reason);
-    };
-    const start = (ctx) => {
-        if (state.active) {
-            ctx.ui.notify(`${config.name} loop is already running`, "warning");
-            return;
-        }
-        state = {
-            active: true,
-            iteration: 0,
-            maxIterations: config.maxIterations,
-        };
-        updateStatus(ctx);
-        ctx.ui.notify(`🔄 Starting ${config.name} auto-loop (max ${state.maxIterations} iterations)...`, "info");
-    };
-    const getState = () => ({ ...state });
-    // --- Event Handlers (registered at module load time) ---
-    // Handle user interruption (any manual input stops the loop)
-    pi.on("input", async (event, ctx) => {
-        if (!ctx.hasUI)
-            return { action: "continue" };
-        if (!state.active)
-            return { action: "continue" };
-        // User typed something manually → stop the auto-loop
-        if (event.source === "interactive") {
-            stop(ctx, "stopped (user interrupted)");
-        }
-        return { action: "continue" };
-    });
-    // Handle end of agent turn → check if we should continue
-    pi.on("agent_end", async (event, ctx) => {
-        if (!ctx.hasUI)
-            return;
-        if (!state.active)
-            return;
-        const assistantMessages = event.messages.filter((m) => m.role === "assistant");
-        const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
-        if (!lastAssistantMessage) {
-            stop(ctx, "stopped (no response)");
-            return;
-        }
-        const textContent = lastAssistantMessage.content
-            .filter((c) => c.type === "text")
-            .map((c) => c.text)
-            .join("\n");
-        if (!textContent.trim()) {
-            stop(ctx, "stopped (empty response)");
-            return;
-        }
-        // Check for completion patterns (explicit success)
-        if (config.completionPatterns) {
-            const hasCompletion = config.completionPatterns.some((p) => p.test(textContent));
-            if (hasCompletion) {
-                complete(ctx, "completed successfully");
-                return;
-            }
-        }
-        // Check for exit patterns (could be success or stopped)
-        const hasExit = config.exitPatterns.some((p) => p.test(textContent));
-        if (hasExit) {
-            complete(ctx, "completed - no more work");
-            return;
-        }
-        // Check if agent is waiting for manual fixes (indicated in the prompt)
-        // If the last message says "When done, run..." we should NOT auto-continue
-        const awaitingManualFix = textContent.includes("When done, run");
-        if (awaitingManualFix) {
-            console.error("[auto-loop] Paused - awaiting agent manual fixes");
-            updateStatus(ctx);
-            // Don't send followUp - wait for agent to manually continue
-            return;
-        }
-        // Check max iterations
-        state.iteration++;
-        if (state.iteration >= state.maxIterations) {
-            stop(ctx, `stopped (max iterations ${state.maxIterations} reached)`);
-            return;
-        }
-        // Continue to next iteration - send command as follow-up
-        updateStatus(ctx);
-        const continueMsg = config.continuePrompt || `Run ${config.command} to continue.`;
-        console.error(`[auto-loop] Triggering iteration ${state.iteration + 1}/${state.maxIterations}: ${config.command}`);
-        pi.sendUserMessage(`🔄 Auto-loop (${state.iteration + 1}/${state.maxIterations}): ${continueMsg}`, { deliverAs: "followUp" });
-    });
-    return {
-        start,
-        stop,
-        getState,
-        setMaxIterations: (n) => {
-            state.maxIterations = n;
-        },
-    };
-}

package/clients/biome-client.js

@@ -1,420 +0,0 @@
-/**
- * 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 {
-    constructor(verbose = false) {
-        this.biomeAvailable = null;
-        this.localBinaryPath = null;
-        this.log = verbose
-            ? (msg) => console.error(`[biome] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Resolve the fastest available biome binary.
-     * Prefers local node_modules/.bin/biome (skip npx overhead ~1s).
-     * Falls back to global biome, then npx.
-     */
-    getBiomeBinary() {
-        if (this.localBinaryPath)
-            return { cmd: this.localBinaryPath, args: [] };
-        // Walk up from cwd looking for node_modules/.bin/biome.
-        // On Windows prefer .cmd (native batch) over the sh wrapper — 2x faster.
-        const isWin = process.platform === "win32";
-        const candidates = isWin
-            ? [
-                path.join(process.cwd(), "node_modules", ".bin", "biome.cmd"),
-                path.join(process.cwd(), "node_modules", ".bin", "biome"),
-            ]
-            : [
-                path.join(process.cwd(), "node_modules", ".bin", "biome"),
-                path.join(process.cwd(), "node_modules", ".bin", "biome.cmd"),
-            ];
-        for (const p of candidates) {
-            if (fs.existsSync(p)) {
-                this.localBinaryPath = p;
-                return { cmd: p, args: [] };
-            }
-        }
-        // Fallback: npx (slower but works anywhere)
-        return { cmd: "npx", args: ["@biomejs/biome"] };
-    }
-    /**
-     * Spawn biome with the fastest available binary.
-     */
-    spawnBiome(args, timeout = 15000) {
-        const { cmd, args: prefix } = this.getBiomeBinary();
-        return safeSpawn(cmd, [...prefix, ...args], { timeout });
-    }
-    /**
-     * Check if biome CLI is available
-     */
-    isAvailable() {
-        if (this.biomeAvailable !== null)
-            return this.biomeAvailable;
-        const result = this.spawnBiome(["--version"], 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;
-    }
-    /**
-     * Ensure Biome is available, auto-installing if necessary.
-     * Prefer this over isAvailable() for auto-install behavior.
-     */
-    async ensureAvailable() {
-        if (this.biomeAvailable !== null)
-            return this.biomeAvailable;
-        // Check if already available
-        const result = this.spawnBiome(["--version"], 10000);
-        if (!result.error && result.status === 0) {
-            this.biomeAvailable = true;
-            return true;
-        }
-        // Auto-install via pi-lens installer
-        this.log("Biome not found, attempting auto-install...");
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("biome");
-        if (installedPath) {
-            this.log(`Biome auto-installed: ${installedPath}`);
-            // Set the installed path as local binary to avoid npx overhead
-            this.localBinaryPath = installedPath;
-            this.biomeAvailable = true;
-            return true;
-        }
-        this.log("Biome auto-install failed");
-        this.biomeAvailable = false;
-        return false;
-    }
-    /**
-     * 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 = this.spawnBiome([
-                "check",
-                "--reporter=json",
-                "--max-diagnostics=50",
-                absolutePath,
-            ]);
-            // 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 = this.spawnBiome(["format", "--write", absolutePath]);
-            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 {
-            // Single invocation: check --write applies safe formatting + lint fixes.
-            // No pre-flight checkFile() needed — content diff tells us if anything changed.
-            const result = this.spawnBiome(["check", "--write", absolutePath]);
-            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 issue(s) in ${path.basename(filePath)}`);
-            }
-            return { success: true, changed, fixed: changed ? 1 : 0 };
-        }
-        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;
-    }
-}