pi-lens 3.1.2 → 3.2.0

package/clients/dispatch/dispatcher.test.js

@@ -1,115 +0,0 @@
-/**
- * Tests for declarative dispatch system
- */
-import { beforeEach, describe, expect, it } from "vitest";
-import { createDispatchContext, getRunner, getRunnersForKind, listRunners, registerRunner, } from "./dispatcher.js";
-// --- Test Runners ---
-const testRunner1 = {
-    id: "test-runner-1",
-    appliesTo: ["jsts", "python"],
-    priority: 10,
-    enabledByDefault: true,
-    async run() {
-        return { status: "succeeded", diagnostics: [], semantic: "none" };
-    },
-};
-const testRunner2 = {
-    id: "test-runner-2",
-    appliesTo: ["python"],
-    priority: 20,
-    enabledByDefault: true,
-    async run() {
-        return { status: "succeeded", diagnostics: [], semantic: "none" };
-    },
-};
-const testRunnerWithCondition = {
-    id: "test-runner-conditional",
-    appliesTo: ["jsts"],
-    priority: 5,
-    enabledByDefault: false,
-    when: async (ctx) => ctx.autofix,
-    async run() {
-        return { status: "succeeded", diagnostics: [], semantic: "none" };
-    },
-};
-// --- Tests ---
-describe("Runner Registry", () => {
-    beforeEach(() => {
-        // Note: In a real test suite, we'd reset the registry between tests
-        registerRunner(testRunner1);
-        registerRunner(testRunner2);
-        registerRunner(testRunnerWithCondition);
-    });
-    it("should register a runner", () => {
-        const runner = getRunner("test-runner-1");
-        expect(runner).toBeDefined();
-        expect(runner?.id).toBe("test-runner-1");
-    });
-    it("should return undefined for unknown runner", () => {
-        const runner = getRunner("unknown-runner");
-        expect(runner).toBeUndefined();
-    });
-    it("should get runners for a specific kind", () => {
-        const jstsRunners = getRunnersForKind("jsts");
-        expect(jstsRunners.length).toBeGreaterThan(0);
-        expect(jstsRunners.some((r) => r.id === "test-runner-1")).toBe(true);
-    });
-    it("should return runners sorted by priority", () => {
-        const jstsRunners = getRunnersForKind("jsts");
-        const priorities = jstsRunners.map((r) => r.priority ?? 100);
-        for (let i = 1; i < priorities.length; i++) {
-            expect(priorities[i - 1]).toBeLessThanOrEqual(priorities[i]);
-        }
-    });
-    it("should list all registered runners", () => {
-        const all = listRunners();
-        expect(all.length).toBeGreaterThanOrEqual(3);
-    });
-    it("should reject duplicate registrations", () => {
-        // This should log an error but not throw
-        expect(() => registerRunner(testRunner1)).not.toThrow();
-    });
-});
-describe("Dispatch Context", () => {
-    it("should create a dispatch context", () => {
-        const mockPi = { getFlag: (flag) => flag === "autofix" };
-        const ctx = createDispatchContext("test.ts", "/project", mockPi);
-        expect(ctx.filePath).toBe("test.ts");
-        expect(ctx.cwd).toBe("/project");
-        expect(ctx.autofix).toBe(false);
-        expect(ctx.deltaMode).toBe(true);
-    });
-    it("should detect file kind", () => {
-        const mockPi = { getFlag: () => false };
-        const ctxTs = createDispatchContext("test.ts", "/project", mockPi);
-        expect(ctxTs.kind).toBe("jsts");
-        const ctxPy = createDispatchContext("test.py", "/project", mockPi);
-        expect(ctxPy.kind).toBe("python");
-        const ctxGo = createDispatchContext("test.go", "/project", mockPi);
-        expect(ctxGo.kind).toBe("go");
-    });
-    it("should respect autofix flag", () => {
-        const mockPiNoFix = { getFlag: (_f) => false };
-        const ctx1 = createDispatchContext("test.ts", "/project", mockPiNoFix);
-        expect(ctx1.autofix).toBe(false);
-        const mockPiWithFix = { getFlag: (f) => f === "autofix-biome" };
-        const ctx2 = createDispatchContext("test.ts", "/project", mockPiWithFix);
-        expect(ctx2.autofix).toBe(true);
-    });
-});
-describe("Conditional Runners", () => {
-    beforeEach(() => {
-        registerRunner(testRunnerWithCondition);
-    });
-    it("should respect when condition", async () => {
-        const runner = getRunner("test-runner-conditional");
-        expect(runner).toBeDefined();
-        const mockPiNoFix = { getFlag: () => false };
-        const ctxNoFix = createDispatchContext("test.ts", "/project", mockPiNoFix);
-        // When autofix is false, the condition should return false
-        if (runner?.when) {
-            const shouldRun = await runner.when(ctxNoFix);
-            expect(shouldRun).toBe(false);
-        }
-    });
-});

package/clients/dispatch/runners/architect.test.js

@@ -1,138 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { describe, expect, it, beforeAll, afterAll } from "vitest";
-function createMockContext(filePath, kind = "jsts", cwd) {
-    return {
-        filePath,
-        cwd: cwd || process.cwd(),
-        kind,
-        autofix: false,
-        deltaMode: false,
-        baselines: { get: () => undefined, set: () => { }, clear: () => { } },
-        pi: { getFlag: () => false },
-        hasTool: async () => false,
-        log: () => { },
-    };
-}
-describe("architect runner", () => {
-    const testDir = path.join(process.env.TEMP || "/tmp", `architect_test_${Date.now()}`);
-    const configPath = path.join(testDir, ".pi-lens", "architect.yaml");
-    beforeAll(() => {
-        // Create test config
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-        fs.writeFileSync(configPath, `version: "1.0"
-rules:
-  - pattern: "**/*.ts"
-    max_lines: 50
-    must_not:
-      - pattern: 'hardcoded_secret_12345'
-        message: "No hardcoded secrets"
-        fix: "Use process.env.SECRET"
-      - pattern: 'console\.log'
-        message: "No console.log in production"
-`);
-    });
-    afterAll(() => {
-        try {
-            if (fs.existsSync(testDir)) {
-                fs.rmSync(testDir, { recursive: true, force: true });
-            }
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    it("should load default config when no user config exists", async () => {
-        const module = await import("./architect.js");
-        const runner = module.default;
-        // Use a unique temp dir with no user config (will fall back to default)
-        const noUserConfigDir = path.join(process.env.TEMP || "/tmp", `no_arch_user_config_${Date.now()}`);
-        fs.mkdirSync(noUserConfigDir, { recursive: true });
-        // Create a very large file that should trigger default max_lines rule
-        const tmpFile = path.join(noUserConfigDir, `large_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, Array(5000).fill("// line").join("\n"));
-        try {
-            const result = await runner.run(createMockContext(tmpFile, "jsts", noUserConfigDir));
-            // Should use default config and find violations
-            expect(result.status).toBe("succeeded");
-            // Should have size violation from default config
-            expect(result.diagnostics.some((d) => d.message.includes("line limit"))).toBe(true);
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile))
-                    fs.unlinkSync(tmpFile);
-                if (fs.existsSync(noUserConfigDir))
-                    fs.rmdirSync(noUserConfigDir);
-            }
-            catch { }
-        }
-    });
-    it("should detect file size violations", async () => {
-        const module = await import("./architect.js");
-        const runner = module.default;
-        const tmpFile = path.join(testDir, `large_file_${Date.now()}.ts`);
-        // Create file with 100 lines (exceeds 50 line limit)
-        fs.writeFileSync(tmpFile, Array(100).fill("// line").join("\n"));
-        try {
-            const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
-            expect(result.status).toBe("succeeded");
-            expect(result.diagnostics.length).toBeGreaterThan(0);
-            expect(result.diagnostics.some((d) => d.message.includes("50 line limit"))).toBe(true);
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile))
-                    fs.unlinkSync(tmpFile);
-            }
-            catch { }
-        }
-    });
-    it("should detect pattern violations", async () => {
-        const module = await import("./architect.js");
-        const runner = module.default;
-        const tmpFile = path.join(testDir, `bad_patterns_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `const x = hardcoded_secret_12345;
-console.log(x);
-`);
-        try {
-            const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
-            expect(result.status).toBe("succeeded");
-            expect(result.diagnostics.length).toBeGreaterThanOrEqual(2);
-            expect(result.diagnostics.some((d) => d.message.includes("hardcoded"))).toBe(true);
-            expect(result.diagnostics.some((d) => d.message.includes("console.log"))).toBe(true);
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile))
-                    fs.unlinkSync(tmpFile);
-            }
-            catch { }
-        }
-    });
-    it("should return no diagnostics for clean files", async () => {
-        const module = await import("./architect.js");
-        const runner = module.default;
-        const tmpFile = path.join(testDir, `clean_${Date.now()}.ts`);
-        // Small file (20 lines) with no violations
-        fs.writeFileSync(tmpFile, Array(20).fill("// clean code").join("\n"));
-        try {
-            const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
-            expect(result.status).toBe("succeeded");
-            expect(result.diagnostics.length).toBe(0);
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile))
-                    fs.unlinkSync(tmpFile);
-            }
-            catch { }
-        }
-    });
-    it("should skip test files", async () => {
-        const module = await import("./architect.js");
-        const runner = module.default;
-        // The runner should have skipTestFiles: true
-        expect(runner.skipTestFiles).toBe(true);
-    });
-});

package/clients/dispatch/runners/ast-grep-napi.test.js

@@ -1,106 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { describe, expect, it } from "vitest";
-function createMockContext(filePath, kind = "jsts") {
-    return {
-        filePath,
-        cwd: process.cwd(),
-        kind,
-        autofix: false,
-        deltaMode: false,
-        baselines: { get: () => [], add: () => { }, save: () => { } },
-        pi: {},
-        hasTool: async () => false,
-        log: () => { },
-    };
-}
-describe("ast-grep-napi vs CLI comparison", () => {
-    it("should load the napi module", async () => {
-        const napiModule = await import("./ast-grep-napi.js");
-        expect(napiModule.default.id).toBe("ast-grep-napi");
-        expect(napiModule.default.appliesTo).toEqual(["jsts"]);
-    });
-    it("should scan TypeScript file and return succeeded status", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `napi_test_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `// Test file with various patterns
-function test(items: string[]) {
-    for (let i = 0; i < items.length; i++) {
-        console.log(items[i]);
-    }
-
-    try {
-        riskyOperation();
-    } catch (e) {
-        // empty catch
-    }
-
-    return await fetchData();
-}
-
-async function fetchData() {
-    return await Promise.resolve(42);
-}
-
-function riskyOperation() {
-    debugger;
-}
-`);
-        try {
-            // Test NAPI version
-            const napiModule = await import("./ast-grep-napi.js");
-            const napiRunner = napiModule.default;
-            console.time("napi");
-            let napiResult;
-            try {
-                napiResult = await napiRunner.run(createMockContext(tmpFile));
-            }
-            catch (error) {
-                console.error("NAPI runner threw error:", error);
-                throw error;
-            }
-            console.timeEnd("napi");
-            console.log("NAPI result status:", napiResult.status);
-            console.log("NAPI result semantic:", napiResult.semantic);
-            console.log("NAPI result diagnostics count:", napiResult.diagnostics?.length);
-            // Should complete successfully (not skipped, not failed)
-            expect(napiResult.status).toBe("succeeded");
-            expect(napiResult.semantic).toBe("warning"); // Has findings, so marked as warning
-            // Log findings
-            console.log("NAPI found:", napiResult.diagnostics.length, "issues");
-            console.log("\n=== NAPI FINDINGS ===");
-            napiResult.diagnostics.forEach((d, i) => {
-                console.log(`${i + 1}. Line ${d.line}: ${d.rule}`);
-            });
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile)) {
-                    fs.unlinkSync(tmpFile);
-                }
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    });
-    it("should skip non-TS/JS files", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `napi_test_py_${Date.now()}.py`);
-        fs.writeFileSync(tmpFile, "# Python file\nprint('hello')");
-        try {
-            const napiModule = await import("./ast-grep-napi.js");
-            const napiRunner = napiModule.default;
-            const result = await napiRunner.run(createMockContext(tmpFile, "python"));
-            expect(result.status).toBe("skipped");
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile)) {
-                    fs.unlinkSync(tmpFile);
-                }
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    });
-});

package/clients/dispatch/runners/oxlint.test.js

@@ -1,230 +0,0 @@
-/**
- * Tests for oxlint runner
- */
-import * as fs from "node:fs";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { describe, expect, it } from "vitest";
-/**
- * Delay helper for Windows file cleanup
- * Windows may hold file handles briefly after process exit
- */
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function createMockContext(filePath, overrides = {}) {
-    return {
-        filePath,
-        cwd: process.cwd(),
-        kind: "jsts",
-        autofix: false,
-        deltaMode: false,
-        baselines: { get: () => [], add: () => { }, save: () => { } },
-        pi: { getFlag: () => false, ...overrides.pi },
-        hasTool: async () => false,
-        log: () => { },
-        ...overrides,
-    };
-}
-describe("oxlint runner", () => {
-    const require = createRequire(import.meta.url);
-    it("should have correct runner definition", async () => {
-        const oxlintModule = await import("./oxlint.js");
-        const runner = oxlintModule.default;
-        expect(runner.id).toBe("oxlint");
-        expect(runner.appliesTo).toEqual(["jsts"]);
-        expect(runner.priority).toBe(12);
-        expect(runner.enabledByDefault).toBe(false); // Opt-in initially
-        expect(runner.skipTestFiles).toBe(true);
-    });
-    it("should detect oxlint availability", () => {
-        const { spawnSync } = require("node:child_process");
-        const result = spawnSync("oxlint", ["--version"], {
-            encoding: "utf-8",
-            timeout: 10000,
-            shell: true,
-        });
-        expect(result.error || result.status !== 0 ? "not available" : "available").toBeTruthy(); // May or may not be installed
-    });
-    it("should detect common lint issues", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_test_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `// Test file with issues
-function test() {
-	// Double negation
-	const flag = !!value;
-	
-	// Unused variable
-	const unused = 42;
-	
-	// Console statement
-	console.log("test");
-}
-`);
-        try {
-            const oxlintModule = await import("./oxlint.js");
-            const runner = oxlintModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            // If oxlint is installed, should detect issues
-            // If not installed, will be skipped
-            if (result.status !== "skipped") {
-                // Should detect at least some issues (console, unused vars, etc.)
-                expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
-                expect(result.diagnostics.some((d) => d.tool === "oxlint" &&
-                    (d.message.includes("console") ||
-                        d.message.includes("unused") ||
-                        d.message.includes("!!")))).toBe(true);
-            }
-        }
-        finally {
-            // Windows may hold file handles briefly - add small delay
-            await delay(100);
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should respect no-oxlint flag", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_flag_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `function test() { console.log("test"); }`);
-        try {
-            const oxlintModule = await import("./oxlint.js");
-            const runner = oxlintModule.default;
-            // Create context with no-oxlint flag set to true
-            const ctxWithFlag = createMockContext(tmpFile, {
-                pi: { getFlag: (name) => name === "no-oxlint" },
-            });
-            const result = await runner.run(ctxWithFlag);
-            expect(result.status).toBe("skipped");
-        }
-        finally {
-            // Windows may hold file handles briefly - add small delay
-            await delay(100);
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should provide fix suggestions when available", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_fix_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `// File with auto-fixable issues
-const x = !!value;
-`);
-        try {
-            const oxlintModule = await import("./oxlint.js");
-            const runner = oxlintModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            if (result.status !== "skipped" && result.diagnostics.length > 0) {
-                // Some issues should be fixable
-                const fixableDiags = result.diagnostics.filter((d) => d.fixable);
-                // At least some diagnostics should have fixes
-                expect(fixableDiags.length).toBeGreaterThanOrEqual(0);
-            }
-        }
-        finally {
-            // Windows may hold file handles briefly - add small delay
-            await delay(100);
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should pass clean TypeScript files", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_ok_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `// Clean TypeScript file
-function greet(name: string): string {
-	return \`Hello, \${name}!\`;
-}
-
-const result = greet("world");
-export { greet };
-`);
-        try {
-            const oxlintModule = await import("./oxlint.js");
-            const runner = oxlintModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            if (result.status !== "skipped") {
-                // Clean files should have no issues
-                expect(result.diagnostics.length).toBe(0);
-                expect(result.status).toBe("succeeded");
-            }
-        }
-        finally {
-            // Windows may hold file handles briefly - add small delay
-            await delay(100);
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should handle JSON output correctly", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_json_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `const unused = 1;`);
-        try {
-            const oxlintModule = await import("./oxlint.js");
-            const runner = oxlintModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            if (result.status !== "skipped") {
-                // All diagnostics should have required fields
-                for (const diag of result.diagnostics) {
-                    expect(diag.id).toBeDefined();
-                    expect(diag.message).toBeDefined();
-                    expect(diag.tool).toBe("oxlint");
-                    expect(diag.line).toBeGreaterThanOrEqual(1);
-                    expect(diag.severity).toMatch(/^(error|warning|info)$/);
-                }
-            }
-        }
-        finally {
-            // Windows may hold file handles briefly - add small delay
-            await delay(100);
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should skip when oxlint is not available", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_skip_${Date.now()}.ts`);
-        fs.writeFileSync(tmpFile, `const x = 1;`);
-        try {
-            const oxlintModule = await import("./oxlint.js");
-            const runner = oxlintModule.default;
-            // Check if oxlint is available
-            const { spawnSync } = require("node:child_process");
-            const checkResult = spawnSync("oxlint", ["--version"], {
-                encoding: "utf-8",
-                timeout: 5000,
-                shell: true,
-            });
-            const isAvailable = !checkResult.error && checkResult.status === 0;
-            const result = await runner.run(createMockContext(tmpFile));
-            if (!isAvailable) {
-                expect(result.status).toBe("skipped");
-                expect(result.diagnostics).toHaveLength(0);
-            }
-        }
-        finally {
-            // Windows may hold file handles briefly - add small delay
-            await delay(100);
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should handle parsing errors gracefully", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_parse_${Date.now()}.ts`);
-        // Intentionally malformed file
-        fs.writeFileSync(tmpFile, `const x = `);
-        try {
-            const oxlintModule = await import("./oxlint.js");
-            const runner = oxlintModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            // Should handle parse errors without crashing
-            expect(["succeeded", "failed", "skipped"]).toContain(result.status);
-        }
-        finally {
-            // Windows may hold file handles briefly - add small delay
-            await delay(100);
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-});

package/clients/dispatch/runners/pyright.test.js

@@ -1,98 +0,0 @@
-import * as fs from "node:fs";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { describe, expect, it } from "vitest";
-function createMockContext(filePath) {
-    return {
-        filePath,
-        cwd: process.cwd(),
-        kind: "python",
-        autofix: false,
-        deltaMode: false,
-        baselines: { get: () => [], add: () => { }, save: () => { } },
-        pi: {},
-        hasTool: async () => false,
-        log: () => { },
-    };
-}
-describe("pyright runner", () => {
-    const require = createRequire(import.meta.url);
-    it("should have correct runner definition", async () => {
-        const pyrightModule = await import("./pyright.js");
-        const runner = pyrightModule.default;
-        expect(runner.id).toBe("pyright");
-        expect(runner.appliesTo).toEqual(["python"]);
-        expect(runner.priority).toBe(5); // Higher priority than ruff
-        expect(runner.enabledByDefault).toBe(true);
-    });
-    it("should detect pyright availability", () => {
-        const { spawnSync } = require("node:child_process");
-        const result = spawnSync("npx", ["pyright", "--version"], {
-            encoding: "utf-8",
-            timeout: 10000,
-            shell: true,
-        });
-        expect(result.error || result.status !== 0 ? "not available" : "available").toBe("available");
-    });
-    it("should type-check Python files and find errors", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `pyright_test_${Date.now()}.py`);
-        fs.writeFileSync(tmpFile, `def add(x: int, y: int) -> int:
-    return x + y
-
-result: str = add(1, 2)
-
-def greet(name: str) -> str:
-    return "Hello " + name
-
-greet(123)
-`);
-        try {
-            const pyrightModule = await import("./pyright.js");
-            const runner = pyrightModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            expect(result.diagnostics.length).toBeGreaterThanOrEqual(2);
-            expect(result.diagnostics.some((d) => d.tool === "pyright")).toBe(true);
-            expect(result.diagnostics.some((d) => d.severity === "error")).toBe(true);
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile)) {
-                    fs.unlinkSync(tmpFile);
-                }
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    });
-    it("should pass valid Python files", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `pyright_test_ok_${Date.now()}.py`);
-        fs.writeFileSync(tmpFile, `def add(x: int, y: int) -> int:
-    return x + y
-
-result: str = str(add(1, 2))
-
-def greet(name: str) -> str:
-    return "Hello " + name
-
-greet("world")
-`);
-        try {
-            const pyrightModule = await import("./pyright.js");
-            const runner = pyrightModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            expect(result.status).toBe("succeeded");
-            expect(result.diagnostics.length).toBe(0);
-        }
-        finally {
-            try {
-                if (fs.existsSync(tmpFile)) {
-                    fs.unlinkSync(tmpFile);
-                }
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    });
-});