pi-lens 3.6.2 → 3.6.4

package/clients/ruff-client.js

@@ -1,325 +0,0 @@
-/**
- * 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 {
-    constructor(verbose = false) {
-        this.ruffAvailable = null;
-        this.log = verbose
-            ? (msg) => console.error(`[ruff] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Check if ruff CLI is available, auto-install if not
-     */
-    async ensureAvailable() {
-        // Fast path: already checked
-        if (this.ruffAvailable !== null)
-            return this.ruffAvailable;
-        // Check if available in PATH
-        const result = safeSpawn("ruff", ["--version"], {
-            timeout: 5000,
-        });
-        this.ruffAvailable = !result.error && result.status === 0;
-        if (this.ruffAvailable) {
-            this.log(`Ruff found: ${result.stdout.trim()}`);
-            return true;
-        }
-        // Auto-install via pi-lens installer
-        this.log("Ruff not found, attempting auto-install...");
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("ruff");
-        if (installedPath) {
-            this.log(`Ruff auto-installed: ${installedPath}`);
-            this.ruffAvailable = true;
-            return true;
-        }
-        this.log("Ruff auto-install failed");
-        return false;
-    }
-    /**
-     * Check if ruff CLI is available (legacy sync method)
-     * Prefer ensureAvailable() for auto-install behavior
-     */
-    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/clients/ruff-client.test.js

@@ -1,132 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { RuffClient } from "./ruff-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("RuffClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new RuffClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ruff-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isPythonFile", () => {
-        it("should recognize Python files", () => {
-            expect(client.isPythonFile("test.py")).toBe(true);
-            expect(client.isPythonFile("module.py")).toBe(true);
-        });
-        it("should not recognize non-Python files", () => {
-            expect(client.isPythonFile("test.ts")).toBe(false);
-            expect(client.isPythonFile("test.js")).toBe(false);
-            expect(client.isPythonFile("test.txt")).toBe(false);
-        });
-    });
-    describe("isAvailable", () => {
-        it("should check ruff availability", () => {
-            const available = client.isAvailable();
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("checkFile", () => {
-        it("should return empty array for non-existent files", () => {
-            if (!client.isAvailable())
-                return;
-            const result = client.checkFile("/nonexistent/file.py");
-            expect(result).toEqual([]);
-        });
-        it("should detect lint issues in Python code", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `
-import os
-import sys
-
-x = 1
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFile(filePath);
-            // Should detect unused imports
-            expect(result.some((d) => d.rule === "F401" || d.message.includes("unused"))).toBe(true);
-        });
-        it("should return array of diagnostics", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `
-def foo():
-    x = undefined_variable
-    return x
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFile(filePath);
-            // Should return an array
-            expect(Array.isArray(result)).toBe(true);
-        });
-    });
-    describe("formatDiagnostics", () => {
-        it("should format diagnostics for display", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "Undefined name 'x'",
-                    rule: "F821",
-                    file: "test.py",
-                    fixable: false,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("Ruff");
-            expect(formatted).toContain("F821");
-            expect(formatted).toContain("Undefined name");
-        });
-        it("should show fixable count", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Unused import",
-                    rule: "F401",
-                    file: "test.py",
-                    fixable: true,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("fixable");
-        });
-    });
-    describe("checkFormatting", () => {
-        it("should detect formatting issues", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `x=1
-y=2
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFormatting(filePath);
-            // Should suggest formatting (missing spaces around =)
-            expect(typeof result).toBe("string");
-        });
-        it("should return empty string for well-formatted code", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `x = 1
-y = 2
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFormatting(filePath);
-            // Well-formatted code should return empty or minimal output
-            expect(result).toBe("");
-        });
-    });
-});

package/clients/ruff-client.test.ts

@@ -1,153 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { RuffClient } from "./ruff-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-
-describe("RuffClient", () => {
-	let client: RuffClient;
-	let tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new RuffClient();
-		({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ruff-test-"));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("isPythonFile", () => {
-		it("should recognize Python files", () => {
-			expect(client.isPythonFile("test.py")).toBe(true);
-			expect(client.isPythonFile("module.py")).toBe(true);
-		});
-
-		it("should not recognize non-Python files", () => {
-			expect(client.isPythonFile("test.ts")).toBe(false);
-			expect(client.isPythonFile("test.js")).toBe(false);
-			expect(client.isPythonFile("test.txt")).toBe(false);
-		});
-	});
-
-	describe("isAvailable", () => {
-		it("should check ruff availability", () => {
-			const available = client.isAvailable();
-			expect(typeof available).toBe("boolean");
-		});
-	});
-
-	describe("checkFile", () => {
-		it("should return empty array for non-existent files", () => {
-			if (!client.isAvailable()) return;
-			const result = client.checkFile("/nonexistent/file.py");
-			expect(result).toEqual([]);
-		});
-
-		it("should detect lint issues in Python code", () => {
-			if (!client.isAvailable()) return;
-
-			const content = `
-import os
-import sys
-
-x = 1
-`;
-			const filePath = createTempFile(tmpDir, "test.py", content);
-			const result = client.checkFile(filePath);
-
-			// Should detect unused imports
-			expect(
-				result.some((d) => d.rule === "F401" || d.message.includes("unused")),
-			).toBe(true);
-		});
-
-		it("should return array of diagnostics", () => {
-			if (!client.isAvailable()) return;
-
-			const content = `
-def foo():
-    x = undefined_variable
-    return x
-`;
-			const filePath = createTempFile(tmpDir, "test.py", content);
-			const result = client.checkFile(filePath);
-
-			// Should return an array
-			expect(Array.isArray(result)).toBe(true);
-		});
-	});
-
-	describe("formatDiagnostics", () => {
-		it("should format diagnostics for display", () => {
-			const diags = [
-				{
-					line: 1,
-					column: 0,
-					endLine: 1,
-					endColumn: 10,
-					severity: "error" as const,
-					message: "Undefined name 'x'",
-					rule: "F821",
-					file: "test.py",
-					fixable: false,
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags);
-			expect(formatted).toContain("Ruff");
-			expect(formatted).toContain("F821");
-			expect(formatted).toContain("Undefined name");
-		});
-
-		it("should show fixable count", () => {
-			const diags = [
-				{
-					line: 1,
-					column: 0,
-					endLine: 1,
-					endColumn: 10,
-					severity: "warning" as const,
-					message: "Unused import",
-					rule: "F401",
-					file: "test.py",
-					fixable: true,
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags);
-			expect(formatted).toContain("fixable");
-		});
-	});
-
-	describe("checkFormatting", () => {
-		it("should detect formatting issues", () => {
-			if (!client.isAvailable()) return;
-
-			const content = `x=1
-y=2
-`;
-			const filePath = createTempFile(tmpDir, "test.py", content);
-			const result = client.checkFormatting(filePath);
-
-			// Should suggest formatting (missing spaces around =)
-			expect(typeof result).toBe("string");
-		});
-
-		it("should return empty string for well-formatted code", () => {
-			if (!client.isAvailable()) return;
-
-			const content = `x = 1
-y = 2
-`;
-			const filePath = createTempFile(tmpDir, "test.py", content);
-			const result = client.checkFormatting(filePath);
-
-			// Well-formatted code should return empty or minimal output
-			expect(result).toBe("");
-		});
-	});
-});

package/clients/rules-scanner.js

@@ -1,97 +0,0 @@
-/**
- * Project rules scanner for pi-lens.
- *
- * Scans for rule files that other tools/agents may have left:
- * - .claude/rules/   — Claude Code rule files
- * - .agents/rules/   — Generic agent rule files
- * - .cursorrules     — Cursor IDE rules
- * - CLAUDE.md        — Claude Code project context
- * - AGENTS.md        — Generic agent context
- *
- * These are surfaced in the system prompt so the agent knows
- * to read them when relevant. pi-lens architect.yaml handles
- * the automated regex-based checks separately.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-const RULE_DIRS = [
-    { dir: ".claude/rules", source: ".claude/rules" },
-    { dir: ".agents/rules", source: ".agents/rules" },
-];
-const RULE_FILES = [
-    { file: "CLAUDE.md", source: "root" },
-    { file: "AGENTS.md", source: "root" },
-    { file: ".cursorrules", source: "root" },
-];
-function findMarkdownFiles(dir, baseDir) {
-    const results = [];
-    if (!fs.existsSync(dir))
-        return results;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            results.push(...findMarkdownFiles(fullPath, baseDir));
-        }
-        else if (entry.isFile() && entry.name.endsWith(".md")) {
-            results.push({
-                source: path.relative(baseDir, dir) || path.basename(baseDir),
-                name: entry.name,
-                filePath: fullPath,
-                relativePath: path.relative(baseDir, fullPath).replace(/\\/g, "/"),
-            });
-        }
-    }
-    return results;
-}
-export function scanProjectRules(cwd) {
-    const rules = [];
-    // Scan rule directories
-    for (const { dir, source } of RULE_DIRS) {
-        const dirPath = path.join(cwd, dir);
-        if (fs.existsSync(dirPath)) {
-            const found = findMarkdownFiles(dirPath, path.join(cwd, dir));
-            for (const rule of found) {
-                rules.push({
-                    source,
-                    name: rule.name,
-                    filePath: rule.filePath,
-                    relativePath: `${dir}/${rule.relativePath}`,
-                });
-            }
-        }
-    }
-    // Check for root-level rule files
-    for (const { file, source } of RULE_FILES) {
-        const filePath = path.join(cwd, file);
-        if (fs.existsSync(filePath)) {
-            rules.push({
-                source,
-                name: file,
-                filePath,
-                relativePath: file,
-            });
-        }
-    }
-    return {
-        rules,
-        hasCustomRules: rules.length > 0,
-    };
-}
-export function formatRulesForPrompt(result) {
-    if (!result.hasCustomRules)
-        return "";
-    // Group by source
-    const bySource = new Map();
-    for (const rule of result.rules) {
-        const existing = bySource.get(rule.source) ?? [];
-        existing.push(rule);
-        bySource.set(rule.source, existing);
-    }
-    const sections = [];
-    for (const [source, rules] of bySource) {
-        const list = rules.map((r) => `- \`${r.relativePath}\``).join("\n");
-        sections.push(`From ${source}/:\n${list}`);
-    }
-    return sections.join("\n\n");
-}