pi-lens 3.6.2 → 3.6.4

package/clients/todo-scanner.test.ts

@@ -1,352 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-import { TodoScanner } from "./todo-scanner.js";
-
-describe("TodoScanner", () => {
-	let client: TodoScanner;
-	let tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new TodoScanner();
-		({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-todo-test-"));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("scanFile", () => {
-		it("should return empty array for non-existent files", () => {
-			const result = client.scanFile("/nonexistent/file.ts");
-			expect(result).toEqual([]);
-		});
-
-		it("should find TODO comments", () => {
-			const content = `
-// TODO: implement this function
-function foo() {}
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("TODO");
-			expect(result[0].message).toContain("implement this function");
-		});
-
-		it("should find FIXME comments", () => {
-			const content = `
-// FIXME: this is broken
-function foo() {}
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("FIXME");
-		});
-
-		it("should find HACK comments", () => {
-			const content = `
-// HACK: temporary workaround
-const x = 1;
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("HACK");
-		});
-
-		it("should find BUG comments", () => {
-			const content = `
-// BUG: this causes a crash
-const x = 1;
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("BUG");
-		});
-
-		it("should find NOTE comments", () => {
-			const content = `
-// NOTE: important design decision
-const x = 1;
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("NOTE");
-		});
-
-		it("should find TODO in block comments", () => {
-			const content = `
-/*
- * TODO: refactor this later
- */
-const x = 1;
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("TODO");
-		});
-
-		it("should find TODO in JSDoc comments", () => {
-			const content = `
-/**
- * TODO: add proper documentation
- */
-function foo() {}
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("TODO");
-		});
-
-		it("should find TODO in Python comments", () => {
-			const content = `
-# TODO: implement this
-def foo():
-    pass
-`;
-			const filePath = createTempFile(tmpDir, "test.py", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(1);
-			expect(result[0].type).toBe("TODO");
-		});
-
-		it("should skip TODO in strings", () => {
-			const content = `
-const message = "TODO: buy milk";
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(0);
-		});
-
-		it("should report correct line numbers", () => {
-			const content = `
-const x = 1;
-const y = 2;
-// TODO: fix this
-const z = 3;
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result[0].line).toBe(4);
-		});
-
-		it("should find multiple annotations in one file", () => {
-			const content = `
-// TODO: first
-// FIXME: second
-// HACK: third
-`;
-			const filePath = createTempFile(tmpDir, "test.ts", content);
-			const result = client.scanFile(filePath);
-
-			expect(result.length).toBe(3);
-		});
-	});
-
-	describe("scanDirectory", () => {
-		it("should scan all files in directory", () => {
-			createTempFile(tmpDir, "file1.ts", "// TODO: task 1");
-			createTempFile(tmpDir, "file2.ts", "// FIXME: bug 1");
-			createTempFile(tmpDir, "file3.py", "# HACK: workaround");
-
-			const result = client.scanDirectory(tmpDir);
-
-			expect(result.items.length).toBe(3);
-		});
-
-		it("should skip node_modules", () => {
-			createTempFile(tmpDir, "src/file.ts", "// TODO: task 1");
-			createTempFile(
-				tmpDir,
-				"node_modules/lib/file.ts",
-				"// TODO: should be skipped",
-			);
-
-			const result = client.scanDirectory(tmpDir);
-
-			expect(result.items.length).toBe(1);
-			expect(result.items[0].file).not.toContain("node_modules");
-		});
-
-		it("should group items by type", () => {
-			createTempFile(tmpDir, "file1.ts", "// TODO: task 1");
-			createTempFile(tmpDir, "file2.ts", "// TODO: task 2");
-			createTempFile(tmpDir, "file3.ts", "// FIXME: bug 1");
-
-			const result = client.scanDirectory(tmpDir);
-
-			expect(result.byType.get("TODO")?.length).toBe(2);
-			expect(result.byType.get("FIXME")?.length).toBe(1);
-		});
-
-		it("should group items by file", () => {
-			createTempFile(tmpDir, "file1.ts", "// TODO: task 1\n// FIXME: bug 1");
-			createTempFile(tmpDir, "file2.ts", "// TODO: task 2");
-
-			const result = client.scanDirectory(tmpDir);
-
-			const file1Items = [...result.byFile.entries()].find(([k]) =>
-				k.includes("file1.ts"),
-			);
-			expect(file1Items?.[1].length).toBe(2);
-		});
-	});
-
-	describe("formatResult", () => {
-		it("should return empty string for no results", () => {
-			const result = { items: [], byType: new Map(), byFile: new Map() };
-			expect(client.formatResult(result)).toBe("");
-		});
-
-		it("should format results with counts", () => {
-			const result = {
-				items: [
-					{
-						type: "TODO" as const,
-						message: "task 1",
-						file: "test.ts",
-						line: 1,
-						column: 0,
-					},
-					{
-						type: "FIXME" as const,
-						message: "bug 1",
-						file: "test.ts",
-						line: 2,
-						column: 0,
-					},
-				],
-				byType: new Map([
-					[
-						"TODO",
-						[
-							{
-								type: "TODO" as const,
-								message: "task 1",
-								file: "test.ts",
-								line: 1,
-								column: 0,
-							},
-						],
-					],
-				]),
-				byFile: new Map([
-					[
-						"test.ts",
-						[
-							{
-								type: "TODO" as const,
-								message: "task 1",
-								file: "test.ts",
-								line: 1,
-								column: 0,
-							},
-						],
-					],
-				]),
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("2 annotation(s)");
-			expect(formatted).toContain("TODO");
-			expect(formatted).toContain("FIXME");
-		});
-
-		it("should prioritize FIXME/HACK before TODO", () => {
-			const result = {
-				items: [
-					{
-						type: "FIXME" as const,
-						message: "bug",
-						file: "test.ts",
-						line: 2,
-						column: 0,
-					},
-					{
-						type: "TODO" as const,
-						message: "task",
-						file: "test.ts",
-						line: 1,
-						column: 0,
-					},
-				],
-				byType: new Map(),
-				byFile: new Map(),
-			};
-
-			const formatted = client.formatResult(result);
-			// Check that FIXME line comes before TODO line in the sorted output
-			const fixmeLineIndex = formatted.indexOf("🔴");
-			const todoLineIndex = formatted.indexOf("📝");
-			expect(fixmeLineIndex).toBeLessThan(todoLineIndex);
-		});
-
-		it("should show correct icons", () => {
-			const result = {
-				items: [
-					{
-						type: "FIXME" as const,
-						message: "bug",
-						file: "test.ts",
-						line: 1,
-						column: 0,
-					},
-					{
-						type: "HACK" as const,
-						message: "hack",
-						file: "test.ts",
-						line: 2,
-						column: 0,
-					},
-					{
-						type: "BUG" as const,
-						message: "bug",
-						file: "test.ts",
-						line: 3,
-						column: 0,
-					},
-					{
-						type: "TODO" as const,
-						message: "todo",
-						file: "test.ts",
-						line: 4,
-						column: 0,
-					},
-					{
-						type: "NOTE" as const,
-						message: "note",
-						file: "test.ts",
-						line: 5,
-						column: 0,
-					},
-				],
-				byType: new Map(),
-				byFile: new Map(),
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("🔴"); // FIXME
-			expect(formatted).toContain("🟠"); // HACK
-			expect(formatted).toContain("🐛"); // BUG
-			expect(formatted).toContain("📝"); // TODO
-			expect(formatted).toContain("ℹ️"); // NOTE
-		});
-	});
-});

package/clients/tool-availability.js

@@ -1,207 +0,0 @@
-/**
- * Tool Availability Caching for pi-lens
- *
- * Provides cached tool availability checks to avoid repeated spawnSync calls.
- * Tools like biome, ruff, ast-grep are checked once per session.
- */
-import { safeSpawn } from "./safe-spawn.js";
-// --- Tool Registry ---
-export const TOOL_REGISTRY = [
-    {
-        name: "biome",
-        command: "npx",
-        versionCommand: ["@biomejs/biome", "--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "ruff",
-        command: "ruff",
-        versionCommand: ["--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "ast-grep",
-        command: "npx",
-        versionCommand: ["sg", "--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "knip",
-        command: "npx",
-        versionCommand: ["knip", "--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "jscpd",
-        command: "npx",
-        versionCommand: ["jscpd", "--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "type-coverage",
-        command: "npx",
-        versionCommand: ["type-coverage", "--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "madge",
-        command: "npx",
-        versionCommand: ["madge", "--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "tsc",
-        command: "npx",
-        versionCommand: ["tsc", "--version"],
-        versionPattern: /Version\s+(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "go",
-        command: "go",
-        versionCommand: ["version"],
-        versionPattern: /go(\d+\.\d+\.\d+)/,
-    },
-    {
-        name: "cargo",
-        command: "cargo",
-        versionCommand: ["--version"],
-        versionPattern: /(\d+\.\d+\.\d+)/,
-    },
-];
-const TOOL_CACHE = new Map();
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-// --- Functions ---
-/**
- * Clear the tool availability cache.
- * Useful for testing or when tool installations change.
- */
-export function clearToolCache() {
-    TOOL_CACHE.clear();
-}
-/**
- * Get cached tool availability or check if available.
- * Uses cached result if within TTL.
- */
-export function isToolAvailable(toolName) {
-    const cached = TOOL_CACHE.get(toolName);
-    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-        return cached.available;
-    }
-    // Check availability
-    const tool = TOOL_REGISTRY.find((t) => t.name === toolName);
-    if (!tool) {
-        // Unknown tool - try direct command check
-        const result = safeSpawn(toolName, ["--version"], {
-            timeout: 5000,
-        });
-        const available = !result.error && result.status === 0;
-        TOOL_CACHE.set(toolName, {
-            available,
-            version: available
-                ? extractVersion(result.stdout + result.stderr, /(\S+)/)
-                : undefined,
-            timestamp: Date.now(),
-        });
-        return available;
-    }
-    // Check using tool's version command
-    if (tool.versionCommand) {
-        const result = safeSpawn(tool.command, tool.versionCommand, {
-            timeout: 10000,
-        });
-        const available = !result.error && result.status === 0;
-        const output = result.stdout + result.stderr;
-        const version = tool.versionPattern
-            ? extractVersion(output, tool.versionPattern)
-            : undefined;
-        TOOL_CACHE.set(toolName, {
-            available,
-            version,
-            timestamp: Date.now(),
-        });
-        return available;
-    }
-    return false;
-}
-/**
- * Get cached tool version if available.
- */
-export function getToolVersion(toolName) {
-    const cached = TOOL_CACHE.get(toolName);
-    if (cached?.version) {
-        return cached.version;
-    }
-    // Try to get version even if not cached
-    const tool = TOOL_REGISTRY.find((t) => t.name === toolName);
-    if (tool?.versionCommand) {
-        const result = safeSpawn(tool.command, tool.versionCommand, {
-            timeout: 10000,
-        });
-        if (!result.error && result.status === 0) {
-            const output = result.stdout + result.stderr;
-            return tool.versionPattern
-                ? extractVersion(output, tool.versionPattern)
-                : output.trim();
-        }
-    }
-    return undefined;
-}
-/**
- * Check multiple tools at once and return their availability.
- */
-export function checkToolsAvailable(toolNames) {
-    const results = new Map();
-    for (const name of toolNames) {
-        results.set(name, isToolAvailable(name));
-    }
-    return results;
-}
-/**
- * Get all available tools.
- */
-export function getAvailableTools() {
-    const available = [];
-    for (const tool of TOOL_REGISTRY) {
-        if (isToolAvailable(tool.name)) {
-            available.push(tool.name);
-        }
-    }
-    return available;
-}
-// --- Helpers ---
-function extractVersion(output, pattern) {
-    const match = output.match(pattern);
-    return match ? match[1] : undefined;
-}
-/**
- * Convenience wrapper for checking common tools.
- */
-export class ToolAvailabilityChecker {
-    constructor(toolNames) {
-        this.toolNames = toolNames;
-    }
-    /**
-     * Check if all tools in the list are available.
-     */
-    allAvailable() {
-        return this.toolNames.every((name) => isToolAvailable(name));
-    }
-    /**
-     * Check if any tool in the list is available.
-     */
-    anyAvailable() {
-        return this.toolNames.some((name) => isToolAvailable(name));
-    }
-    /**
-     * Get list of available tools in this list.
-     */
-    getAvailable() {
-        return this.toolNames.filter((name) => isToolAvailable(name));
-    }
-    /**
-     * Get list of unavailable tools in this list.
-     */
-    getUnavailable() {
-        return this.toolNames.filter((name) => !isToolAvailable(name));
-    }
-}