pi-lens 3.1.2 → 3.2.0

package/rules/tree-sitter-queries/typescript/constructor-super.yml

@@ -0,0 +1,55 @@
+# Constructor Super Call Detection
+# Detects derived class constructors that don't call super()
+id: constructor-super
+name: Missing super() call in derived class constructor
+severity: error
+category: correctness
+language: typescript
+
+message: "Constructor of derived class must call super() before accessing 'this'"
+
+description: |
+  Constructors of derived classes must call super() before accessing 'this'.
+  This is a JavaScript runtime requirement that throws if violated.
+
+query: |
+  (class_declaration
+    (class_heritage
+      (extends_clause) @EXTENDS)
+    body: (class_body
+      (method_definition
+        name: (property_identifier) @CONSTRUCTOR
+        (#eq? @CONSTRUCTOR "constructor")
+        body: (statement_block) @BODY)))
+
+metavars:
+  - EXTENDS
+  - CONSTRUCTOR
+  - BODY
+
+post_filter: "no_super_call"
+post_filter_params: {}
+
+tags:
+  - correctness
+  - javascript
+  - typescript
+  - constructor
+
+examples:
+  bad: |
+    class Derived extends Base {
+      constructor() {
+        this.value = 1; // ERROR: must call super() first
+      }
+    }
+
+  good: |
+    class Derived extends Base {
+      constructor() {
+        super();
+        this.value = 1;
+      }
+    }
+
+has_fix: false

package/rules/tree-sitter-queries/typescript/debugger.yml

@@ -2,7 +2,7 @@
 # Detects debugger statements left in code
 id: debugger-statement
 name: Debugger Statement
-severity: warning
+severity: error
 category: debugging
 language: typescript
 

package/rules/tree-sitter-queries/typescript/no-dupe-class-members.yml

@@ -0,0 +1,47 @@
+# Duplicate Class Members Detection
+# Detects duplicate method/property definitions in classes
+id: no-dupe-class-members
+name: Duplicate class member
+severity: error
+category: correctness
+language: typescript
+
+message: "Duplicate class member '$NAME' - previous declaration will be overwritten"
+
+description: |
+  Duplicate class member declarations silently overwrite each other.
+  The last declaration wins, which can cause unexpected behavior.
+
+query: |
+  (class_body
+    (method_definition
+      name: (property_identifier) @NAME1
+      (#match? @NAME1 "^[^#]"))
+    (method_definition
+      name: (property_identifier) @NAME2
+      (#eq? @NAME1 @NAME2)))
+
+metavars:
+  - NAME1
+  - NAME2
+
+tags:
+  - correctness
+  - javascript
+  - typescript
+  - class
+
+examples:
+  bad: |
+    class MyClass {
+      foo() { return 1; }
+      foo() { return 2; } // Overwrites first foo()
+    }
+
+  good: |
+    class MyClass {
+      foo() { return 1; }
+      bar() { return 2; }
+    }
+
+has_fix: false

package/tsconfig.json

@@ -10,5 +10,5 @@
 		"types": ["node"]
 	},
 	"include": ["**/*.ts"],
-	"exclude": ["node_modules"]
+	"exclude": ["node_modules", "test-lsp-files"]
 }

package/clients/__tests__/file-time.test.js

@@ -1,216 +0,0 @@
-/**
- * FileTime Tracking Tests
- *
- * Tests the safety mechanism that prevents race conditions
- * between auto-formatting and agent edits.
- */
-import { describe, it, expect, beforeEach } from "vitest";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { FileTime, FileTimeError, createFileTime, clearAllSessions } from "../file-time.js";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const TEST_DIR = path.join(__dirname, "..", "..", "test-filetime");
-describe("FileTime", () => {
-    let fileTime;
-    const sessionID = "test-session";
-    beforeEach(() => {
-        clearAllSessions();
-        fileTime = new FileTime(sessionID);
-        // Ensure test directory exists
-        if (!fs.existsSync(TEST_DIR)) {
-            fs.mkdirSync(TEST_DIR, { recursive: true });
-        }
-    });
-    describe("read()", () => {
-        it("should record file stamp with mtime/ctime/size", () => {
-            const testFile = path.join(TEST_DIR, "test1.txt");
-            fs.writeFileSync(testFile, "hello");
-            const stamp = fileTime.read(testFile);
-            expect(stamp.readAt).toBeInstanceOf(Date);
-            expect(stamp.mtime).toBeDefined();
-            expect(stamp.ctime).toBeDefined();
-            expect(stamp.size).toBe(5);
-        });
-        it("should handle non-existent files gracefully", () => {
-            const testFile = path.join(TEST_DIR, "nonexistent.txt");
-            const stamp = fileTime.read(testFile);
-            expect(stamp.readAt).toBeInstanceOf(Date);
-            expect(stamp.mtime).toBeUndefined();
-            expect(stamp.ctime).toBeUndefined();
-            expect(stamp.size).toBeUndefined();
-        });
-        it("should track multiple files per session", () => {
-            const file1 = path.join(TEST_DIR, "file1.txt");
-            const file2 = path.join(TEST_DIR, "file2.txt");
-            fs.writeFileSync(file1, "content1");
-            fs.writeFileSync(file2, "content2");
-            fileTime.read(file1);
-            fileTime.read(file2);
-            expect(fileTime.get(file1)).toBeDefined();
-            expect(fileTime.get(file2)).toBeDefined();
-        });
-    });
-    describe("get()", () => {
-        it("should return undefined for unread files", () => {
-            const testFile = path.join(TEST_DIR, "unread.txt");
-            const stamp = fileTime.get(testFile);
-            expect(stamp).toBeUndefined();
-        });
-        it("should return recorded stamp for read files", () => {
-            const testFile = path.join(TEST_DIR, "test2.txt");
-            fs.writeFileSync(testFile, "content");
-            const recorded = fileTime.read(testFile);
-            const retrieved = fileTime.get(testFile);
-            expect(retrieved?.mtime).toBe(recorded.mtime);
-            expect(retrieved?.ctime).toBe(recorded.ctime);
-            expect(retrieved?.size).toBe(recorded.size);
-        });
-    });
-    describe("assert()", () => {
-        it("should throw FileTimeError for unread files", () => {
-            const testFile = path.join(TEST_DIR, "never-read.txt");
-            fs.writeFileSync(testFile, "content");
-            expect(() => fileTime.assert(testFile)).toThrow(FileTimeError);
-            expect(() => fileTime.assert(testFile)).toThrow(/must read file/);
-        });
-        it("should not throw for unchanged files", () => {
-            const testFile = path.join(TEST_DIR, "unchanged.txt");
-            fs.writeFileSync(testFile, "content");
-            fileTime.read(testFile);
-            expect(() => fileTime.assert(testFile)).not.toThrow();
-        });
-        it("should throw FileTimeError when file modified externally", () => {
-            const testFile = path.join(TEST_DIR, "modified.txt");
-            fs.writeFileSync(testFile, "original");
-            fileTime.read(testFile);
-            // Simulate external modification
-            fs.writeFileSync(testFile, "modified content");
-            expect(() => fileTime.assert(testFile)).toThrow(FileTimeError);
-            expect(() => fileTime.assert(testFile)).toThrow(/modified since it was last read/);
-        });
-        it("should detect size changes", () => {
-            const testFile = path.join(TEST_DIR, "size-change.txt");
-            fs.writeFileSync(testFile, "original content");
-            fileTime.read(testFile);
-            // Truncate file (size change, mtime change)
-            fs.writeFileSync(testFile, "x");
-            expect(() => fileTime.assert(testFile)).toThrow(FileTimeError);
-        });
-    });
-    describe("hasChanged()", () => {
-        it("should return true for unread files", () => {
-            const testFile = path.join(TEST_DIR, "unread-check.txt");
-            fs.writeFileSync(testFile, "content");
-            expect(fileTime.hasChanged(testFile)).toBe(true);
-        });
-        it("should return false for unchanged files", () => {
-            const testFile = path.join(TEST_DIR, "unchanged-check.txt");
-            fs.writeFileSync(testFile, "content");
-            fileTime.read(testFile);
-            expect(fileTime.hasChanged(testFile)).toBe(false);
-        });
-        it("should return true when file modified", () => {
-            const testFile = path.join(TEST_DIR, "changed-check.txt");
-            fs.writeFileSync(testFile, "original");
-            fileTime.read(testFile);
-            fs.writeFileSync(testFile, "changed");
-            expect(fileTime.hasChanged(testFile)).toBe(true);
-        });
-    });
-    describe("withLock()", () => {
-        it("should execute function exclusively", async () => {
-            const testFile = path.join(TEST_DIR, "locked.txt");
-            const executionOrder = [];
-            const fn1 = async () => {
-                executionOrder.push("start1");
-                await new Promise(r => setTimeout(r, 50));
-                executionOrder.push("end1");
-                return "result1";
-            };
-            const fn2 = async () => {
-                executionOrder.push("start2");
-                await new Promise(r => setTimeout(r, 50));
-                executionOrder.push("end2");
-                return "result2";
-            };
-            // Start both, but they should execute sequentially
-            const promise1 = fileTime.withLock(testFile, fn1);
-            const promise2 = fileTime.withLock(testFile, fn2);
-            await Promise.all([promise1, promise2]);
-            // Should be sequential, not interleaved
-            expect(executionOrder).toEqual(["start1", "end1", "start2", "end2"]);
-        });
-        it("should return function result", async () => {
-            const testFile = path.join(TEST_DIR, "lock-result.txt");
-            const result = await fileTime.withLock(testFile, async () => {
-                return "success";
-            });
-            expect(result).toBe("success");
-        });
-    });
-    describe("clear()", () => {
-        it("should clear all tracked files for session", () => {
-            const file1 = path.join(TEST_DIR, "clear1.txt");
-            const file2 = path.join(TEST_DIR, "clear2.txt");
-            fs.writeFileSync(file1, "a");
-            fs.writeFileSync(file2, "b");
-            fileTime.read(file1);
-            fileTime.read(file2);
-            fileTime.clear();
-            expect(fileTime.get(file1)).toBeUndefined();
-            expect(fileTime.get(file2)).toBeUndefined();
-        });
-    });
-    describe("cross-session isolation", () => {
-        it("should isolate file tracking between sessions", () => {
-            const testFile = path.join(TEST_DIR, "isolated.txt");
-            fs.writeFileSync(testFile, "content");
-            const session1 = new FileTime("session1");
-            const session2 = new FileTime("session2");
-            session1.read(testFile);
-            // session2 should not see session1's reads
-            expect(() => session2.assert(testFile)).toThrow(FileTimeError);
-            expect(() => session2.assert(testFile)).toThrow(/must read file/);
-        });
-    });
-    describe("FileTimeError", () => {
-        it("should have correct error properties", () => {
-            const testFile = path.join(TEST_DIR, "error.txt");
-            fs.writeFileSync(testFile, "content");
-            try {
-                fileTime.assert(testFile);
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(FileTimeError);
-                expect(error.name).toBe("FileTimeError");
-                expect(error.filePath).toBe(path.resolve(testFile));
-                expect(error.reason).toBe("not-read");
-            }
-        });
-    });
-});
-describe("createFileTime helper", () => {
-    it("should create FileTime instance with session ID", () => {
-        const ft = createFileTime("my-session");
-        expect(ft).toBeInstanceOf(FileTime);
-    });
-});
-describe("clearAllSessions helper", () => {
-    it("should clear all session tracking", () => {
-        const ft1 = createFileTime("session1");
-        const ft2 = createFileTime("session2");
-        const testFile = path.join(TEST_DIR, "clearall.txt");
-        fs.writeFileSync(testFile, "x");
-        ft1.read(testFile);
-        ft2.read(testFile);
-        clearAllSessions();
-        // After clearing, both should throw "not read"
-        const ft1New = createFileTime("session1");
-        const ft2New = createFileTime("session2");
-        expect(() => ft1New.assert(testFile)).toThrow(/must read file/);
-        expect(() => ft2New.assert(testFile)).toThrow(/must read file/);
-    });
-});

package/clients/__tests__/format-service.test.js

@@ -1,245 +0,0 @@
-/**
- * Format Service Tests
- *
- * Tests concurrent formatter execution via Effect-TS
- * and FileTime integration for safety.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { FileTimeError } from "../file-time.js";
-import { FormatService, getFormatService, resetFormatService, } from "../format-service.js";
-import { clearAllSessions } from "../file-time.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const TEST_DIR = path.join(__dirname, "..", "..", "test-format-service");
-describe("FormatService", () => {
-    let formatService;
-    const sessionID = "test-format-session";
-    beforeEach(() => {
-        resetFormatService();
-        clearAllSessions(); // Clear FileTime global state for test isolation
-        formatService = new FormatService(sessionID, true);
-        if (fs.existsSync(TEST_DIR)) {
-            fs.rmSync(TEST_DIR, { recursive: true });
-        }
-        fs.mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterEach(() => {
-        resetFormatService();
-        clearAllSessions(); // Clear FileTime global state for test isolation
-        if (fs.existsSync(TEST_DIR)) {
-            fs.rmSync(TEST_DIR, { recursive: true });
-        }
-    });
-    describe("formatFile()", () => {
-        it("should skip formatting when disabled", async () => {
-            const disabledService = new FormatService(sessionID, false);
-            const testFile = path.join(TEST_DIR, "disabled.txt");
-            fs.writeFileSync(testFile, "content");
-            const result = await disabledService.formatFile(testFile);
-            expect(result.formatters).toEqual([]);
-            expect(result.anyChanged).toBe(false);
-            expect(result.allSucceeded).toBe(true);
-        });
-        it("should skip formatting with skip option", async () => {
-            const testFile = path.join(TEST_DIR, "skipped.txt");
-            fs.writeFileSync(testFile, "content");
-            const result = await formatService.formatFile(testFile, { skip: true });
-            expect(result.formatters).toEqual([]);
-            expect(result.anyChanged).toBe(false);
-            expect(result.allSucceeded).toBe(true);
-        });
-        it("should skip when file modified externally", async () => {
-            const testFile = path.join(TEST_DIR, "external.txt");
-            fs.writeFileSync(testFile, "original");
-            // Record read
-            formatService.recordRead(testFile);
-            // Modify externally
-            fs.writeFileSync(testFile, "modified");
-            const result = await formatService.formatFile(testFile);
-            expect(result.formatters).toEqual([]);
-            expect(result.anyChanged).toBe(false);
-            expect(result.allSucceeded).toBe(false);
-        });
-        it("should format TypeScript file with biome config", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), '{"formatter": {}}');
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            fs.writeFileSync(tsFile, "const x=1;");
-            // Record read so format service knows initial state
-            formatService.recordRead(tsFile);
-            const result = await formatService.formatFile(tsFile);
-            expect(result.filePath).toBe(tsFile);
-            expect(result.formatters.some((f) => f.name === "biome")).toBe(true);
-        });
-        it("should format Python file with ruff config", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.ruff]\nline-length = 100");
-            const pyFile = path.join(TEST_DIR, "test.py");
-            fs.writeFileSync(pyFile, "x=1");
-            // Record read so format service knows initial state
-            formatService.recordRead(pyFile);
-            const result = await formatService.formatFile(pyFile);
-            expect(result.filePath).toBe(pyFile);
-            expect(result.formatters.some((f) => f.name === "ruff")).toBe(true);
-        });
-        it("should run multiple formatters for same file", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }));
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            fs.writeFileSync(tsFile, "const x = 1;");
-            formatService.recordRead(tsFile);
-            const result = await formatService.formatFile(tsFile);
-            const names = result.formatters.map((f) => f.name);
-            expect(names).toContain("biome");
-        });
-        it("should return empty result for unsupported file", async () => {
-            const txtFile = path.join(TEST_DIR, "test.txt");
-            fs.writeFileSync(txtFile, "content");
-            formatService.recordRead(txtFile);
-            const result = await formatService.formatFile(txtFile);
-            expect(result.formatters).toEqual([]);
-            expect(result.anyChanged).toBe(false);
-            expect(result.allSucceeded).toBe(true);
-        });
-        it("should record FileTime after formatting", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            fs.writeFileSync(tsFile, "const x = 1;");
-            formatService.recordRead(tsFile);
-            await formatService.formatFile(tsFile);
-            expect(() => formatService.assertUnchanged(tsFile)).not.toThrow();
-        });
-        it("should report success/failure for each formatter", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            fs.writeFileSync(tsFile, "const x = 1;");
-            formatService.recordRead(tsFile);
-            const result = await formatService.formatFile(tsFile);
-            for (const formatter of result.formatters) {
-                expect(formatter).toHaveProperty("name");
-                expect(formatter).toHaveProperty("success");
-                expect(formatter).toHaveProperty("changed");
-                expect(typeof formatter.success).toBe("boolean");
-                expect(typeof formatter.changed).toBe("boolean");
-            }
-        });
-        it("should re-read file content after formatting", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            fs.writeFileSync(tsFile, "const x = 1;");
-            formatService.recordRead(tsFile);
-            const _result = await formatService.formatFile(tsFile);
-            const after = fs.readFileSync(tsFile, "utf-8");
-            expect(after).toBeDefined();
-        });
-    });
-    describe("assertUnchanged()", () => {
-        it("should not throw for unchanged files", async () => {
-            const testFile = path.join(TEST_DIR, "unchanged.txt");
-            fs.writeFileSync(testFile, "content");
-            formatService.recordRead(testFile);
-            expect(() => formatService.assertUnchanged(testFile)).not.toThrow();
-        });
-        it("should throw FileTimeError when file modified", async () => {
-            const testFile = path.join(TEST_DIR, "modified.txt");
-            fs.writeFileSync(testFile, "original");
-            formatService.recordRead(testFile);
-            fs.writeFileSync(testFile, "changed");
-            expect(() => formatService.assertUnchanged(testFile)).toThrow(FileTimeError);
-        });
-    });
-    describe("hasChanged()", () => {
-        it("should return false for unchanged files", async () => {
-            const testFile = path.join(TEST_DIR, "unchanged-check.txt");
-            fs.writeFileSync(testFile, "content");
-            formatService.recordRead(testFile);
-            expect(formatService.hasChanged(testFile)).toBe(false);
-        });
-        it("should return true when file modified", async () => {
-            const testFile = path.join(TEST_DIR, "changed-check.txt");
-            fs.writeFileSync(testFile, "original");
-            formatService.recordRead(testFile);
-            // Small delay to ensure different mtime (Windows has ~16ms resolution)
-            await new Promise((r) => setTimeout(r, 50));
-            fs.writeFileSync(testFile, "modified");
-            expect(formatService.hasChanged(testFile)).toBe(true);
-        });
-        it("should return true for unread files", async () => {
-            const testFile = path.join(TEST_DIR, "never-read.txt");
-            fs.writeFileSync(testFile, "content");
-            expect(formatService.hasChanged(testFile)).toBe(true);
-        });
-    });
-    describe("recordRead()", () => {
-        it("should record file read for tracking", async () => {
-            const testFile = path.join(TEST_DIR, "tracked.txt");
-            fs.writeFileSync(testFile, "content");
-            formatService.recordRead(testFile);
-            expect(formatService.hasChanged(testFile)).toBe(false);
-        });
-    });
-    describe("clearCache()", () => {
-        it("should clear formatter detection cache", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            fs.writeFileSync(tsFile, "const x = 1;");
-            formatService.recordRead(tsFile);
-            await formatService.formatFile(tsFile);
-            formatService.clearCache();
-            await formatService.formatFile(tsFile);
-        });
-    });
-    describe("Concurrency", () => {
-        it("should handle multiple files concurrently", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const files = [
-                path.join(TEST_DIR, "file1.ts"),
-                path.join(TEST_DIR, "file2.ts"),
-                path.join(TEST_DIR, "file3.ts"),
-            ];
-            for (const file of files) {
-                fs.writeFileSync(file, "const x = 1;");
-                formatService.recordRead(file);
-            }
-            const results = await Promise.all(files.map((f) => formatService.formatFile(f)));
-            expect(results).toHaveLength(3);
-            for (const result of results) {
-                expect(result.filePath).toBeDefined();
-                expect(result.formatters.length).toBeGreaterThan(0);
-            }
-        });
-    });
-});
-describe("getFormatService singleton", () => {
-    beforeEach(() => {
-        resetFormatService();
-    });
-    afterEach(() => {
-        resetFormatService();
-    });
-    it("should return singleton instance", () => {
-        const instance1 = getFormatService();
-        const instance2 = getFormatService();
-        expect(instance1).toBe(instance2);
-    });
-    it("should create new instance when session ID provided", () => {
-        const instance1 = getFormatService("session1");
-        const instance2 = getFormatService("session2");
-        expect(instance1).not.toBe(instance2);
-    });
-    it("should use cached instance regardless of enabled flag changes", () => {
-        const first = getFormatService("test", true);
-        const second = getFormatService("test", false);
-        expect(first).toBe(second);
-    });
-});
-describe("resetFormatService", () => {
-    it("should reset singleton instance", () => {
-        const instance1 = getFormatService();
-        resetFormatService();
-        const instance2 = getFormatService();
-        expect(instance1).not.toBe(instance2);
-    });
-});