pi-lens 3.1.2 → 3.2.0

package/clients/__tests__/formatters.test.js

@@ -1,271 +0,0 @@
-/**
- * Formatter Detection Tests
- *
- * Tests smart detection of formatters based on:
- * - Config files (biome.json, .prettierrc, etc.)
- * - Dependencies (package.json, requirements.txt)
- * - Binary availability
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { biomeFormatter, prettierFormatter, ruffFormatter, blackFormatter, gofmtFormatter, rustfmtFormatter, getFormattersForFile, clearFormatterCache, formatFile, } from "../formatters.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-formatters");
-describe("Formatter Detection", () => {
-    beforeEach(() => {
-        clearFormatterCache();
-        if (fs.existsSync(TEST_DIR)) {
-            fs.rmSync(TEST_DIR, { recursive: true });
-        }
-        fs.mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterEach(() => {
-        clearFormatterCache();
-        if (fs.existsSync(TEST_DIR)) {
-            fs.rmSync(TEST_DIR, { recursive: true });
-        }
-    });
-    describe("biomeFormatter.detect()", () => {
-        it("should detect biome.json config file", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), '{"formatter": {}}');
-            const detected = await biomeFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect biome.jsonc config file", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.jsonc"), "{}");
-            const detected = await biomeFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect @biomejs/biome in devDependencies", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { "@biomejs/biome": "^1.0.0" } }));
-            const detected = await biomeFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should return false when no biome config", async () => {
-            const detected = await biomeFormatter.detect(TEST_DIR);
-            expect(detected).toBe(false);
-        });
-        it("should find biome.json in parent directory", async () => {
-            const subDir = path.join(TEST_DIR, "src", "components");
-            fs.mkdirSync(subDir, { recursive: true });
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const detected = await biomeFormatter.detect(subDir);
-            expect(detected).toBe(true);
-        });
-    });
-    describe("prettierFormatter.detect()", () => {
-        it("should detect .prettierrc config file", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, ".prettierrc"), "{}");
-            const detected = await prettierFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect prettier in devDependencies", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }));
-            const detected = await prettierFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect prettier field in package.json", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ prettier: { semi: false } }));
-            const detected = await prettierFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should return false when no prettier config", async () => {
-            const detected = await prettierFormatter.detect(TEST_DIR);
-            expect(detected).toBe(false);
-        });
-    });
-    describe("ruffFormatter.detect()", () => {
-        it("should detect [tool.ruff] in pyproject.toml", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.ruff]\nline-length = 100");
-            const detected = await ruffFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect ruff.toml config file", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "ruff.toml"), "line-length = 100");
-            const detected = await ruffFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect .ruff.toml config file", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, ".ruff.toml"), "line-length = 100");
-            const detected = await ruffFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect ruff in requirements.txt", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "requirements.txt"), "ruff==0.1.0\n");
-            const detected = await ruffFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect ruff even if [tool.black] exists (no preference logic)", async () => {
-            // Create pyproject.toml with black config
-            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.black]\nline-length = 100");
-            // Also write requirements with ruff
-            fs.writeFileSync(path.join(TEST_DIR, "requirements.txt"), "ruff\n");
-            // The current implementation doesn't have preference logic
-            // Both black and ruff would be detected if their configs exist
-            // This is intentional - users can disable one if needed
-            const detected = await blackFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-    });
-    describe("blackFormatter.detect()", () => {
-        it("should detect [tool.black] in pyproject.toml", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.black]\nline-length = 100");
-            const detected = await blackFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should detect black in requirements.txt", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "requirements.txt"), "black==23.0.0\n");
-            const detected = await blackFormatter.detect(TEST_DIR);
-            expect(detected).toBe(true);
-        });
-        it("should return false when no black config", async () => {
-            const detected = await blackFormatter.detect(TEST_DIR);
-            expect(detected).toBe(false);
-        });
-    });
-    describe("gofmtFormatter.detect()", () => {
-        it("should detect gofmt binary availability", async () => {
-            // This test depends on whether gofmt is installed
-            // We can't reliably test this in CI, but we can verify the logic
-            const detected = await gofmtFormatter.detect(TEST_DIR);
-            // Should return boolean based on binary availability
-            expect(typeof detected).toBe("boolean");
-        });
-    });
-    describe("rustfmtFormatter.detect()", () => {
-        it("should detect rustfmt binary availability", async () => {
-            const detected = await rustfmtFormatter.detect(TEST_DIR);
-            expect(typeof detected).toBe("boolean");
-        });
-    });
-    describe("getFormattersForFile()", () => {
-        it("should return formatters for TypeScript file with biome config", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
-            expect(formatters.map(f => f.name)).toContain("biome");
-        });
-        it("should return formatters for TypeScript file with prettier", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }));
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
-            expect(formatters.map(f => f.name)).toContain("prettier");
-        });
-        it("should return multiple formatters for TypeScript 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");
-            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
-            // Both biome and prettier should be returned
-            expect(formatters.length).toBeGreaterThanOrEqual(1);
-            const names = formatters.map(f => f.name);
-            expect(names).toContain("biome");
-        });
-        it("should return ruff for Python file with pyproject.toml", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.ruff]\nline-length = 100");
-            const pyFile = path.join(TEST_DIR, "test.py");
-            const formatters = await getFormattersForFile(pyFile, TEST_DIR);
-            expect(formatters.map(f => f.name)).toContain("ruff");
-        });
-        it("should return black for Python file with black config", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.black]\nline-length = 100");
-            const pyFile = path.join(TEST_DIR, "test.py");
-            const formatters = await getFormattersForFile(pyFile, TEST_DIR);
-            // Should prefer black over ruff
-            expect(formatters.map(f => f.name)).toContain("black");
-        });
-        it("should return empty array for unsupported extensions", async () => {
-            const txtFile = path.join(TEST_DIR, "test.txt");
-            fs.writeFileSync(txtFile, "content");
-            const formatters = await getFormattersForFile(txtFile, TEST_DIR);
-            expect(formatters).toEqual([]);
-        });
-        it("should cache detection results", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            // First call
-            await getFormattersForFile(tsFile, TEST_DIR);
-            // Second call should use cache
-            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
-            expect(formatters.map(f => f.name)).toContain("biome");
-        });
-    });
-    describe("clearFormatterCache()", () => {
-        it("should clear cached detection results", async () => {
-            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
-            const tsFile = path.join(TEST_DIR, "test.ts");
-            // First detection
-            await getFormattersForFile(tsFile, TEST_DIR);
-            // Clear cache
-            clearFormatterCache();
-            // Delete config
-            fs.rmSync(path.join(TEST_DIR, "biome.json"));
-            // Should re-detect (now without biome)
-            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
-            expect(formatters.map(f => f.name)).not.toContain("biome");
-        });
-    });
-    describe("formatFile()", () => {
-        it("should format file and report changes", async () => {
-            // Create a simple test - we'll skip actual formatter execution
-            // because we can't guarantee formatters are installed
-            const testFile = path.join(TEST_DIR, "test.txt");
-            fs.writeFileSync(testFile, "unchanged");
-            const mockFormatter = {
-                name: "mock",
-                command: ["echo", "$FILE"],
-                extensions: [".txt"],
-                detect: async () => true,
-            };
-            const result = await formatFile(testFile, mockFormatter);
-            // echo command should succeed but not change file
-            expect(result.success).toBe(true);
-        });
-        it("should handle formatter execution with valid command", async () => {
-            const testFile = path.join(TEST_DIR, "valid.txt");
-            fs.writeFileSync(testFile, "content");
-            // Use a valid command that succeeds but doesn't modify file
-            const mockFormatter = {
-                name: "valid",
-                command: process.platform === "win32" ? ["cmd", "/c", "echo", "$FILE"] : ["echo", "$FILE"],
-                extensions: [".txt"],
-                detect: async () => true,
-            };
-            const result = await formatFile(testFile, mockFormatter);
-            // Should not throw, completes with success
-            expect(result).toBeDefined();
-            expect(typeof result.success).toBe("boolean");
-        });
-    });
-    describe("Formatter extensions", () => {
-        it("biome should handle TS/JS/JSON/CSS/Vue/Svelte", () => {
-            expect(biomeFormatter.extensions).toContain(".ts");
-            expect(biomeFormatter.extensions).toContain(".tsx");
-            expect(biomeFormatter.extensions).toContain(".js");
-            expect(biomeFormatter.extensions).toContain(".json");
-            expect(biomeFormatter.extensions).toContain(".css");
-            expect(biomeFormatter.extensions).toContain(".vue");
-            expect(biomeFormatter.extensions).toContain(".svelte");
-        });
-        it("prettier should handle Markdown and YAML", () => {
-            expect(prettierFormatter.extensions).toContain(".md");
-            expect(prettierFormatter.extensions).toContain(".mdx");
-            expect(prettierFormatter.extensions).toContain(".yaml");
-            expect(prettierFormatter.extensions).toContain(".yml");
-        });
-        it("ruff should handle Python files", () => {
-            expect(ruffFormatter.extensions).toContain(".py");
-            expect(ruffFormatter.extensions).toContain(".pyi");
-        });
-        it("gofmt should handle Go files", () => {
-            expect(gofmtFormatter.extensions).toContain(".go");
-        });
-        it("rustfmt should handle Rust files", () => {
-            expect(rustfmtFormatter.extensions).toContain(".rs");
-        });
-    });
-});

package/clients/agent-behavior-client.test.js

@@ -1,94 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { AgentBehaviorClient } from "./agent-behavior-client.js";
-describe("AgentBehaviorClient", () => {
-    let client;
-    beforeEach(() => {
-        client = new AgentBehaviorClient();
-        client.reset();
-    });
-    describe("blind write detection", () => {
-        it("should NOT warn when read precedes write", () => {
-            client.recordToolCall("read", "src/file.ts");
-            client.recordToolCall("edit", "src/file.ts");
-            const warnings = client.recordToolCall("write", "src/file.ts");
-            expect(warnings).toHaveLength(0);
-        });
-        it("should warn when multiple writes happen without reads", () => {
-            // First write is OK (no history)
-            client.recordToolCall("write", "src/file1.ts");
-            // Second write - still in window, accumulates
-            client.recordToolCall("edit", "src/file2.ts");
-            // Third write without any read - now we have a pattern
-            const warnings = client.recordToolCall("edit", "src/file3.ts");
-            expect(warnings).toHaveLength(1);
-            expect(warnings[0].type).toBe("blind-write");
-        });
-        it("should not warn for single write with no history", () => {
-            const warnings = client.recordToolCall("write", "src/file.ts");
-            expect(warnings).toHaveLength(0);
-        });
-    });
-    describe("thrashing detection", () => {
-        it("should warn after 3 consecutive identical tool calls", () => {
-            client.recordToolCall("bash", undefined);
-            // Second call - no warning yet
-            let warnings = client.recordToolCall("bash", undefined);
-            expect(warnings).toHaveLength(0);
-            // Third consecutive - should warn
-            warnings = client.recordToolCall("bash", undefined);
-            expect(warnings).toHaveLength(1);
-            expect(warnings[0].type).toBe("thrashing");
-            expect(warnings[0].details.callCount).toBe(3);
-        });
-        it("should NOT warn for different tool calls", () => {
-            client.recordToolCall("read", "src/file.ts");
-            client.recordToolCall("bash", "npm test");
-            const warnings = client.recordToolCall("edit", "src/file.ts");
-            expect(warnings).toHaveLength(0);
-        });
-        it("should reset count when tool changes", () => {
-            client.recordToolCall("bash", undefined);
-            client.recordToolCall("bash", undefined);
-            // Different tool resets the count
-            client.recordToolCall("read", "src/file.ts");
-            // Now start new consecutive sequence
-            client.recordToolCall("bash", undefined);
-            const warnings = client.recordToolCall("bash", undefined);
-            expect(warnings).toHaveLength(0); // Only 2 consecutive, not 3
-        });
-    });
-    describe("edit counting", () => {
-        it("should track edit count per file", () => {
-            client.recordToolCall("edit", "src/a.ts");
-            client.recordToolCall("edit", "src/a.ts");
-            client.recordToolCall("edit", "src/b.ts");
-            expect(client.getEditCount("src/a.ts")).toBe(2);
-            expect(client.getEditCount("src/b.ts")).toBe(1);
-            expect(client.getEditCount("src/c.ts")).toBe(0);
-        });
-    });
-    describe("formatWarnings", () => {
-        it("should format multiple warnings", () => {
-            const warnings = [
-                {
-                    type: "blind-write",
-                    message: "⚠ BLIND WRITE — editing file",
-                    severity: "warning",
-                    details: {},
-                },
-                {
-                    type: "thrashing",
-                    message: "🔴 THRASHING — 3 consecutive calls",
-                    severity: "error",
-                    details: {},
-                },
-            ];
-            const formatted = client.formatWarnings(warnings);
-            expect(formatted).toContain("BLIND WRITE");
-            expect(formatted).toContain("THRASHING");
-        });
-        it("should return empty string for no warnings", () => {
-            expect(client.formatWarnings([])).toBe("");
-        });
-    });
-});

package/clients/ast-grep-client.test.js

@@ -1,129 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AstGrepClient } from "./ast-grep-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("AstGrepClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new AstGrepClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-astgrep-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isAvailable", () => {
-        it("should check ast-grep availability", () => {
-            const available = client.isAvailable();
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("scanFile", () => {
-        it("should return empty array for non-existent files", () => {
-            if (!client.isAvailable())
-                return;
-            const result = client.scanFile("/nonexistent/file.ts");
-            expect(result).toEqual([]);
-        });
-        it("should detect console.log usage", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `
-console.log("test");
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            // Should detect console.log
-            expect(result.some((d) => d.rule === "no-console-log")).toBe(true);
-        });
-    });
-    describe("formatDiagnostics", () => {
-        it("should format diagnostics for display", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Unexpected var, use let or const instead",
-                    rule: "no-var",
-                    file: "test.ts",
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("ast-grep");
-            expect(formatted).toContain("no-var");
-        });
-        it("should categorize by severity", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Warning",
-                    rule: "rule1",
-                    file: "test.ts",
-                },
-                {
-                    line: 2,
-                    column: 0,
-                    endLine: 2,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "Error",
-                    rule: "rule2",
-                    file: "test.ts",
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("warning(s)");
-            expect(formatted).toContain("error(s)");
-        });
-        it("should show fixable indicator", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Use const",
-                    rule: "prefer-const",
-                    file: "test.ts",
-                    fix: "const",
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("fixable");
-        });
-    });
-    describe("search", () => {
-        it("should search for patterns", async () => {
-            if (!client.isAvailable())
-                return;
-            createTempFile(tmpDir, "test.ts", `
-function test() {
-  console.log("hello");
-}
-`);
-            const result = await client.search("console.log($MSG)", "typescript", [
-                tmpDir,
-            ]);
-            expect(result.matches.length).toBeGreaterThan(0);
-        });
-        it("should return empty matches for no match", async () => {
-            if (!client.isAvailable())
-                return;
-            createTempFile(tmpDir, "test.ts", `
-const x = 1;
-`);
-            const result = await client.search("console.log($MSG)", "typescript", [
-                tmpDir,
-            ]);
-            expect(result.matches.length).toBe(0);
-        });
-    });
-});

package/clients/ast-grep-client.test.ts

@@ -1,155 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AstGrepClient } from "./ast-grep-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-
-describe("AstGrepClient", () => {
-	let client: AstGrepClient;
-	let tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new AstGrepClient();
-		({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-astgrep-test-"));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("isAvailable", () => {
-		it("should check ast-grep availability", () => {
-			const available = client.isAvailable();
-			expect(typeof available).toBe("boolean");
-		});
-	});
-
-	describe("scanFile", () => {
-		it("should return empty array for non-existent files", () => {
-			if (!client.isAvailable()) return;
-			const result = client.scanFile("/nonexistent/file.ts");
-			expect(result).toEqual([]);
-		});
-
-		it("should detect console.log usage", () => {
-			if (!client.isAvailable()) return;
-
-			const content = `
-console.log("test");
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			// Should detect console.log
-			expect(result.some((d) => d.rule === "no-console-log")).toBe(true);
-		});
-	});
-
-	describe("formatDiagnostics", () => {
-		it("should format diagnostics for display", () => {
-			const diags = [
-				{
-					line: 1,
-					column: 0,
-					endLine: 1,
-					endColumn: 10,
-					severity: "warning" as const,
-					message: "Unexpected var, use let or const instead",
-					rule: "no-var",
-					file: "test.ts",
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags);
-			expect(formatted).toContain("ast-grep");
-			expect(formatted).toContain("no-var");
-		});
-
-		it("should categorize by severity", () => {
-			const diags = [
-				{
-					line: 1,
-					column: 0,
-					endLine: 1,
-					endColumn: 10,
-					severity: "warning" as const,
-					message: "Warning",
-					rule: "rule1",
-					file: "test.ts",
-				},
-				{
-					line: 2,
-					column: 0,
-					endLine: 2,
-					endColumn: 10,
-					severity: "error" as const,
-					message: "Error",
-					rule: "rule2",
-					file: "test.ts",
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags);
-			expect(formatted).toContain("warning(s)");
-			expect(formatted).toContain("error(s)");
-		});
-
-		it("should show fixable indicator", () => {
-			const diags = [
-				{
-					line: 1,
-					column: 0,
-					endLine: 1,
-					endColumn: 10,
-					severity: "warning" as const,
-					message: "Use const",
-					rule: "prefer-const",
-					file: "test.ts",
-					fix: "const",
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags);
-			expect(formatted).toContain("fixable");
-		});
-	});
-
-	describe("search", () => {
-		it("should search for patterns", async () => {
-			if (!client.isAvailable()) return;
-
-			createTempFile(
-				tmpDir,
-				"test.ts",
-				`
-function test() {
-  console.log("hello");
-}
-`,
-			);
-
-			const result = await client.search("console.log($MSG)", "typescript", [
-				tmpDir,
-			]);
-
-			expect(result.matches.length).toBeGreaterThan(0);
-		});
-
-		it("should return empty matches for no match", async () => {
-			if (!client.isAvailable()) return;
-
-			createTempFile(
-				tmpDir,
-				"test.ts",
-				`
-const x = 1;
-`,
-			);
-
-			const result = await client.search("console.log($MSG)", "typescript", [
-				tmpDir,
-			]);
-
-			expect(result.matches.length).toBe(0);
-		});
-	});
-});