pi-lens 3.6.2 → 3.6.4

package/clients/biome-client.test.js

@@ -1,144 +0,0 @@
-import * as fs from "node:fs";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { BiomeClient } from "./biome-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("BiomeClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new BiomeClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-biome-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isSupportedFile", () => {
-        it("should support JS/TS files", () => {
-            expect(client.isSupportedFile("test.js")).toBe(true);
-            expect(client.isSupportedFile("test.jsx")).toBe(true);
-            expect(client.isSupportedFile("test.ts")).toBe(true);
-            expect(client.isSupportedFile("test.tsx")).toBe(true);
-            expect(client.isSupportedFile("test.mjs")).toBe(true);
-            expect(client.isSupportedFile("test.cjs")).toBe(true);
-        });
-        it("should support CSS and JSON", () => {
-            expect(client.isSupportedFile("style.css")).toBe(true);
-            expect(client.isSupportedFile("config.json")).toBe(true);
-        });
-        it("should not support unsupported files", () => {
-            expect(client.isSupportedFile("test.py")).toBe(false);
-            expect(client.isSupportedFile("test.md")).toBe(false);
-            expect(client.isSupportedFile("test.txt")).toBe(false);
-        });
-    });
-    describe("isAvailable", () => {
-        it("should check biome availability", () => {
-            const available = client.isAvailable();
-            // Just verify it doesn't throw - actual availability depends on environment
-            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.ts");
-            expect(result).toEqual([]);
-        });
-        it("should return array of diagnostics for TS files", {
-            timeout: 15000,
-        }, () => {
-            if (!client.isAvailable())
-                return;
-            const content = `
-const x: number = "string";
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.checkFile(filePath);
-            // Should return an array (may or may not have issues)
-            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: "Unexpected var",
-                    rule: "noVar",
-                    category: "lint",
-                    fixable: true,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags, "test.ts");
-            expect(formatted).toContain("Biome");
-            expect(formatted).toContain("1 issue");
-            expect(formatted).toContain("noVar");
-        });
-        it("should show fixable count", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "Error 1",
-                    rule: "rule1",
-                    category: "lint",
-                    fixable: true,
-                },
-                {
-                    line: 2,
-                    column: 0,
-                    endLine: 2,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Warning 1",
-                    rule: "rule2",
-                    category: "lint",
-                    fixable: false,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags, "test.ts");
-            expect(formatted).toContain("1 fixable");
-        });
-        it("should truncate long diagnostic lists", () => {
-            const diags = Array.from({ length: 20 }, (_, i) => ({
-                line: i + 1,
-                column: 0,
-                endLine: i + 1,
-                endColumn: 10,
-                severity: "warning",
-                message: `Warning ${i}`,
-                rule: `rule${i}`,
-                category: "lint",
-                fixable: false,
-            }));
-            const formatted = client.formatDiagnostics(diags, "test.ts");
-            expect(formatted).toContain("...");
-            expect(formatted).toContain("5 more");
-        });
-    });
-    describe("formatFile", () => {
-        it("should format a file", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `const x={a:1,b:2}`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.formatFile(filePath);
-            expect(result.success).toBe(true);
-            // Check if file was formatted (should have spaces)
-            const formatted = fs.readFileSync(filePath, "utf-8");
-            expect(formatted).toContain(": "); // Should have spaces after colons
-        });
-    });
-});

package/clients/biome-client.test.ts

@@ -1,163 +0,0 @@
-import * as fs from "node:fs";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { BiomeClient } from "./biome-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-
-describe("BiomeClient", () => {
-	let client: BiomeClient;
-	let tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new BiomeClient();
-		({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-biome-test-"));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("isSupportedFile", () => {
-		it("should support JS/TS files", () => {
-			expect(client.isSupportedFile("test.js")).toBe(true);
-			expect(client.isSupportedFile("test.jsx")).toBe(true);
-			expect(client.isSupportedFile("test.ts")).toBe(true);
-			expect(client.isSupportedFile("test.tsx")).toBe(true);
-			expect(client.isSupportedFile("test.mjs")).toBe(true);
-			expect(client.isSupportedFile("test.cjs")).toBe(true);
-		});
-
-		it("should support CSS and JSON", () => {
-			expect(client.isSupportedFile("style.css")).toBe(true);
-			expect(client.isSupportedFile("config.json")).toBe(true);
-		});
-
-		it("should not support unsupported files", () => {
-			expect(client.isSupportedFile("test.py")).toBe(false);
-			expect(client.isSupportedFile("test.md")).toBe(false);
-			expect(client.isSupportedFile("test.txt")).toBe(false);
-		});
-	});
-
-	describe("isAvailable", () => {
-		it("should check biome availability", () => {
-			const available = client.isAvailable();
-			// Just verify it doesn't throw - actual availability depends on environment
-			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.ts");
-			expect(result).toEqual([]);
-		});
-
-		it("should return array of diagnostics for TS files", {
-			timeout: 15000,
-		}, () => {
-			if (!client.isAvailable()) return;
-
-			const content = `
-const x: number = "string";
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.checkFile(filePath);
-
-			// Should return an array (may or may not have issues)
-			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: "Unexpected var",
-					rule: "noVar",
-					category: "lint" as const,
-					fixable: true,
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags, "test.ts");
-			expect(formatted).toContain("Biome");
-			expect(formatted).toContain("1 issue");
-			expect(formatted).toContain("noVar");
-		});
-
-		it("should show fixable count", () => {
-			const diags = [
-				{
-					line: 1,
-					column: 0,
-					endLine: 1,
-					endColumn: 10,
-					severity: "error" as const,
-					message: "Error 1",
-					rule: "rule1",
-					category: "lint" as const,
-					fixable: true,
-				},
-				{
-					line: 2,
-					column: 0,
-					endLine: 2,
-					endColumn: 10,
-					severity: "warning" as const,
-					message: "Warning 1",
-					rule: "rule2",
-					category: "lint" as const,
-					fixable: false,
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags, "test.ts");
-			expect(formatted).toContain("1 fixable");
-		});
-
-		it("should truncate long diagnostic lists", () => {
-			const diags = Array.from({ length: 20 }, (_, i) => ({
-				line: i + 1,
-				column: 0,
-				endLine: i + 1,
-				endColumn: 10,
-				severity: "warning" as const,
-				message: `Warning ${i}`,
-				rule: `rule${i}`,
-				category: "lint" as const,
-				fixable: false,
-			}));
-
-			const formatted = client.formatDiagnostics(diags, "test.ts");
-			expect(formatted).toContain("...");
-			expect(formatted).toContain("5 more");
-		});
-	});
-
-	describe("formatFile", () => {
-		it("should format a file", () => {
-			if (!client.isAvailable()) return;
-
-			const content = `const x={a:1,b:2}`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-
-			const result = client.formatFile(filePath);
-			expect(result.success).toBe(true);
-
-			// Check if file was formatted (should have spaces)
-			const formatted = fs.readFileSync(filePath, "utf-8");
-			expect(formatted).toContain(": "); // Should have spaces after colons
-		});
-	});
-});

package/clients/cache/rule-cache.js

@@ -1,72 +0,0 @@
-/**
- * Rule Cache for pi-lens
- *
- * Provides disk-based caching for parsed tree-sitter rules with
- * automatic invalidation based on rule file modification times.
- */
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-const CACHE_DIR = path.join(process.cwd(), ".pi-lens", "cache");
-const CACHE_VERSION = "v1";
-export class RuleCache {
-    constructor(language) {
-        this.cacheFile = path.join(CACHE_DIR, `${language}-rules-${CACHE_VERSION}.json`);
-    }
-    ensureCacheDir() {
-        if (!fs.existsSync(CACHE_DIR)) {
-            fs.mkdirSync(CACHE_DIR, { recursive: true });
-        }
-    }
-    computeRuleHash(ruleFiles) {
-        const hash = crypto.createHash("sha256");
-        for (const file of ruleFiles.sort()) {
-            if (fs.existsSync(file)) {
-                const stat = fs.statSync(file);
-                hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
-            }
-        }
-        return hash.digest("hex").slice(0, 16);
-    }
-    get(ruleFiles) {
-        try {
-            this.ensureCacheDir();
-            if (!fs.existsSync(this.cacheFile))
-                return null;
-            const cached = JSON.parse(fs.readFileSync(this.cacheFile, "utf-8"));
-            const currentHash = this.computeRuleHash(ruleFiles);
-            if (cached.version !== CACHE_VERSION || cached.ruleHash !== currentHash) {
-                return null; // Cache invalid
-            }
-            return cached;
-        }
-        catch {
-            return null;
-        }
-    }
-    set(ruleFiles, queries) {
-        try {
-            this.ensureCacheDir();
-            const entry = {
-                version: CACHE_VERSION,
-                timestamp: Date.now(),
-                ruleHash: this.computeRuleHash(ruleFiles),
-                queries,
-            };
-            fs.writeFileSync(this.cacheFile, JSON.stringify(entry, null, 2));
-        }
-        catch {
-            // Cache write failure is non-fatal
-        }
-    }
-    clear() {
-        try {
-            if (fs.existsSync(this.cacheFile)) {
-                fs.unlinkSync(this.cacheFile);
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
-}

package/clients/cache-manager.js

@@ -1,245 +0,0 @@
-/**
- * CacheManager for pi-lens.
- *
- * Manages persistent cache for scanner results and turn state.
- * Provides read/write/freshness checks for:
- * - Scanner cache: .pi-lens/cache/{scanner}.json
- * - Turn state: .pi-lens/turn-state.json
- *
- * All paths are relative to project root (process.cwd()).
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-// --- Defaults ---
-const DEFAULT_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
-const DEFAULT_TURN_STATE = {
-    files: {},
-    turnCycles: 0,
-    maxCycles: 3,
-    lastUpdated: "",
-};
-// --- Helpers ---
-function getLensDir(cwd) {
-    return path.join(cwd, ".pi-lens");
-}
-function getCacheDir(cwd) {
-    return path.join(getLensDir(cwd), "cache");
-}
-function getTurnStatePath(cwd) {
-    return path.join(getLensDir(cwd), "turn-state.json");
-}
-// --- Cache Manager ---
-export class CacheManager {
-    constructor(verbose = false) {
-        this.log = verbose
-            ? (msg) => console.error(`[cache] ${msg}`)
-            : () => { };
-    }
-    // ---- Scanner Cache ----
-    /**
-     * Read a scanner cache entry. Returns null if not found or stale.
-     */
-    readCache(scanner, cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
-        const cachePath = path.join(getCacheDir(cwd), `${scanner}.json`);
-        const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-        if (!fs.existsSync(cachePath) || !fs.existsSync(metaPath)) {
-            this.log(`Cache miss: ${scanner} (files don't exist)`);
-            return null;
-        }
-        try {
-            const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
-            const age = Date.now() - new Date(meta.timestamp).getTime();
-            if (age > maxAgeMs) {
-                this.log(`Cache stale: ${scanner} (age: ${Math.round(age / 1000)}s, max: ${maxAgeMs / 1000}s)`);
-                return null;
-            }
-            const data = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
-            this.log(`Cache hit: ${scanner} (age: ${Math.round(age / 1000)}s)`);
-            return { data, meta };
-        }
-        catch (err) {
-            this.log(`Cache read error: ${scanner} — ${err}`);
-            return null;
-        }
-    }
-    /**
-     * Write a scanner cache entry.
-     */
-    writeCache(scanner, data, cwd, extraMeta) {
-        const cacheDir = getCacheDir(cwd);
-        fs.mkdirSync(cacheDir, { recursive: true });
-        const cachePath = path.join(cacheDir, `${scanner}.json`);
-        const metaPath = path.join(cacheDir, `${scanner}.meta.json`);
-        const meta = {
-            timestamp: new Date().toISOString(),
-            ...extraMeta,
-        };
-        fs.writeFileSync(cachePath, JSON.stringify(data, null, 2));
-        fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
-        this.log(`Cache written: ${scanner}`);
-    }
-    /**
-     * Check if a cache entry is fresh (exists and not expired).
-     */
-    isCacheFresh(scanner, cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
-        const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-        if (!fs.existsSync(metaPath))
-            return false;
-        try {
-            const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
-            const age = Date.now() - new Date(meta.timestamp).getTime();
-            return age <= maxAgeMs;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Clear a specific cache entry.
-     */
-    clearCache(scanner, cwd) {
-        const cachePath = path.join(getCacheDir(cwd), `${scanner}.json`);
-        const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
-        for (const p of [cachePath, metaPath]) {
-            try {
-                fs.unlinkSync(p);
-            }
-            catch (err) {
-                // ENOENT: file doesn't exist, other errors logged
-                if (err.code !== "ENOENT") {
-                    this.log(`Failed to delete ${p}: ${err}`);
-                }
-            }
-        }
-    }
-    // ---- Turn State ----
-    /**
-     * Read turn state. Returns default if not found.
-     */
-    readTurnState(cwd) {
-        const statePath = getTurnStatePath(cwd);
-        if (!fs.existsSync(statePath)) {
-            return {
-                ...DEFAULT_TURN_STATE,
-                files: {},
-                lastUpdated: new Date().toISOString(),
-            };
-        }
-        try {
-            return JSON.parse(fs.readFileSync(statePath, "utf-8"));
-        }
-        catch {
-            return {
-                ...DEFAULT_TURN_STATE,
-                files: {},
-                lastUpdated: new Date().toISOString(),
-            };
-        }
-    }
-    /**
-     * Write turn state.
-     */
-    writeTurnState(state, cwd) {
-        const lensDir = getLensDir(cwd);
-        fs.mkdirSync(lensDir, { recursive: true });
-        const statePath = getTurnStatePath(cwd);
-        state.lastUpdated = new Date().toISOString();
-        fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-    }
-    /**
-     * Add or update a file's modified ranges in turn state.
-     * Merges overlapping ranges.
-     */
-    addModifiedRange(filePath, range, importsChanged, cwd) {
-        const state = this.readTurnState(cwd);
-        const normalizedPath = path.relative(cwd, filePath).replace(/\\/g, "/");
-        const existing = state.files[normalizedPath];
-        if (existing) {
-            // Merge ranges
-            existing.modifiedRanges = this.mergeRanges([
-                ...existing.modifiedRanges,
-                range,
-            ]);
-            existing.importsChanged = existing.importsChanged || importsChanged;
-            existing.lastEdit = new Date().toISOString();
-        }
-        else {
-            state.files[normalizedPath] = {
-                modifiedRanges: [range],
-                importsChanged,
-                lastEdit: new Date().toISOString(),
-            };
-        }
-        this.writeTurnState(state, cwd);
-        return state;
-    }
-    /**
-     * Clear turn state (after turn_end processes it).
-     */
-    clearTurnState(cwd) {
-        const state = {
-            ...DEFAULT_TURN_STATE,
-            files: {}, // fresh object — DEFAULT_TURN_STATE.files can be polluted by addModifiedRange
-            lastUpdated: new Date().toISOString(),
-        };
-        this.writeTurnState(state, cwd);
-    }
-    /**
-     * Increment turn cycle counter.
-     */
-    incrementTurnCycle(cwd) {
-        const state = this.readTurnState(cwd);
-        state.turnCycles++;
-        this.writeTurnState(state, cwd);
-        return state;
-    }
-    /**
-     * Check if max cycles exceeded.
-     */
-    isMaxCyclesExceeded(cwd) {
-        const state = this.readTurnState(cwd);
-        return state.turnCycles >= state.maxCycles;
-    }
-    /**
-     * Get files that need jscpd re-scan (any edit).
-     */
-    getFilesForJscpd(cwd) {
-        const state = this.readTurnState(cwd);
-        return Object.keys(state.files);
-    }
-    /**
-     * Get files that need madge re-scan (imports changed).
-     */
-    getFilesForMadge(cwd) {
-        const state = this.readTurnState(cwd);
-        return Object.entries(state.files)
-            .filter(([, f]) => f.importsChanged)
-            .map(([p]) => p);
-    }
-    // ---- Utilities ----
-    /**
-     * Merge overlapping or adjacent ranges.
-     */
-    mergeRanges(ranges) {
-        if (ranges.length === 0)
-            return [];
-        const sorted = [...ranges].sort((a, b) => a.start - b.start);
-        const merged = [sorted[0]];
-        for (const current of sorted.slice(1)) {
-            const last = merged[merged.length - 1];
-            if (current.start <= last.end + 1) {
-                last.end = Math.max(last.end, current.end);
-            }
-            else {
-                merged.push({ ...current });
-            }
-        }
-        return merged;
-    }
-    /**
-     * Check if a line falls within any modified range.
-     */
-    isLineInModifiedRange(line, ranges) {
-        return ranges.some((r) => r.start <= line && line <= r.end);
-    }
-}