pi-lens 3.6.2 → 3.6.4

package/clients/todo-scanner.js

@@ -1,200 +0,0 @@
-/**
- * TODO Scanner for pi-local.
- *
- * Scans codebase for TODO, FIXME, HACK, XXX, and other annotations.
- * Helps me understand what's already flagged as problematic or incomplete.
- *
- * No dependencies required — uses regex scanning.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-// --- Scanner ---
-export class TodoScanner {
-    constructor() {
-        this.pattern = /\b(TODO|FIXME|HACK|XXX|NOTE|DEPRECATED|BUG)\b\s*[(:]?\s*(.+)/gi;
-    }
-    /**
-     * Check if a match position is inside a comment context.
-     * Handles: // line comments, star-slash block comments, * JSDoc lines, # Python comments
-     */
-    isInComment(line, matchIndex) {
-        const trimmed = line.trimStart();
-        // Line starts with comment markers — entire line is a comment
-        if (/^\/\/|^\/\*|^\*|^#/.test(trimmed))
-            return true;
-        // Check if there's a // before the match position (not inside a string)
-        const beforeMatch = line.slice(0, matchIndex);
-        const lineCommentPos = beforeMatch.lastIndexOf("//");
-        if (lineCommentPos !== -1) {
-            // Count quotes before // to see if it's inside a string
-            const beforeComment = beforeMatch.slice(0, lineCommentPos);
-            const singleQuotes = (beforeComment.match(/'/g) || []).length;
-            const doubleQuotes = (beforeComment.match(/"/g) || []).length;
-            const backticks = (beforeComment.match(/`/g) || []).length;
-            if (singleQuotes % 2 === 0 &&
-                doubleQuotes % 2 === 0 &&
-                backticks % 2 === 0) {
-                return true;
-            }
-        }
-        // Check for /* ... */ block comment before match
-        const blockOpen = beforeMatch.lastIndexOf("/*");
-        const blockClose = beforeMatch.lastIndexOf("*/");
-        if (blockOpen !== -1 && blockClose < blockOpen)
-            return true;
-        // Check for # comment (Python)
-        const hashPos = beforeMatch.lastIndexOf("#");
-        if (hashPos !== -1) {
-            const beforeHash = beforeMatch.slice(0, hashPos);
-            const singleQuotes = (beforeHash.match(/'/g) || []).length;
-            const doubleQuotes = (beforeHash.match(/"/g) || []).length;
-            if (singleQuotes % 2 === 0 && doubleQuotes % 2 === 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Scan a single file for TODOs
-     */
-    scanFile(filePath) {
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
-            return [];
-        const content = fs.readFileSync(absolutePath, "utf-8");
-        const lines = content.split("\n");
-        const items = [];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const matches = line.matchAll(this.pattern);
-            for (const match of matches) {
-                // Skip matches that aren't inside comments
-                if (!this.isInComment(line, match.index ?? 0))
-                    continue;
-                const type = match[1].toUpperCase();
-                const message = (match[2] || "").trim().replace(/\s*\*\/\s*$/, ""); // Strip closing comment
-                items.push({
-                    type,
-                    message: message.slice(0, 200), // Limit message length
-                    file: path.relative(process.cwd(), absolutePath),
-                    line: i + 1,
-                    column: match.index || 0,
-                });
-            }
-        }
-        return items;
-    }
-    /**
-     * Scan a directory recursively
-     */
-    scanDirectory(dirPath, extensions = [".ts", ".tsx", ".js", ".jsx", ".py"]) {
-        const items = [];
-        const scan = (dir) => {
-            if (!fs.existsSync(dir))
-                return;
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    // Skip common non-source directories
-                    if ([
-                        "node_modules",
-                        ".git",
-                        "dist",
-                        "build",
-                        ".next",
-                        "coverage",
-                    ].includes(entry.name))
-                        continue;
-                    scan(fullPath);
-                }
-                else if (extensions.some((ext) => entry.name.endsWith(ext))) {
-                    // Skip this scanner file — its own type literals and regex cause false positives
-                    if (entry.name === "todo-scanner.ts" ||
-                        entry.name === "todo-scanner.js")
-                        continue;
-                    // Skip test files — intentional annotations are test fixtures, not work items
-                    if (/\.(test|spec)\.[jt]sx?$/.test(entry.name))
-                        continue;
-                    items.push(...this.scanFile(fullPath));
-                }
-            }
-        };
-        scan(path.resolve(dirPath));
-        // Group by type
-        const byType = new Map();
-        for (const item of items) {
-            const existing = byType.get(item.type) || [];
-            existing.push(item);
-            byType.set(item.type, existing);
-        }
-        // Group by file
-        const byFile = new Map();
-        for (const item of items) {
-            const existing = byFile.get(item.file) || [];
-            existing.push(item);
-            byFile.set(item.file, existing);
-        }
-        return { items, byType, byFile };
-    }
-    /**
-     * Format scan results for LLM consumption
-     */
-    formatResult(result, maxItems = 30) {
-        if (result.items.length === 0)
-            return "";
-        let output = `[TODOs] ${result.items.length} annotation(s) found`;
-        // Summary by type
-        const typeCounts = [];
-        for (const [type, items] of result.byType) {
-            typeCounts.push(`${items.length} ${type}`);
-        }
-        if (typeCounts.length > 0) {
-            output += ` (${typeCounts.join(", ")})`;
-        }
-        output += ":\n";
-        // Show by priority: FIXME/HACK first, then TODO
-        const priorityOrder = [
-            "FIXME",
-            "HACK",
-            "BUG",
-            "DEPRECATED",
-            "TODO",
-            "XXX",
-            "NOTE",
-        ];
-        const sorted = [...result.items].sort((a, b) => {
-            const aIdx = priorityOrder.indexOf(a.type);
-            const bIdx = priorityOrder.indexOf(b.type);
-            return (aIdx === -1 ? 99 : aIdx) - (bIdx === -1 ? 99 : bIdx);
-        });
-        for (const item of sorted.slice(0, maxItems)) {
-            const icon = this.getIcon(item.type);
-            output += `  ${icon} ${item.file}:${item.line} — ${item.type}: ${item.message}\n`;
-        }
-        if (result.items.length > maxItems) {
-            output += `  ... and ${result.items.length - maxItems} more\n`;
-        }
-        return output;
-    }
-    getIcon(type) {
-        switch (type) {
-            case "FIXME":
-                return "🔴";
-            case "HACK":
-                return "🟠";
-            case "BUG":
-                return "🐛";
-            case "DEPRECATED":
-                return "⚠️";
-            case "TODO":
-                return "📝";
-            case "XXX":
-                return "❌";
-            case "NOTE":
-                return "ℹ️";
-            default:
-                return "•";
-        }
-    }
-}

package/clients/todo-scanner.test.js

@@ -1,301 +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;
-    let tmpDir;
-    let cleanup;
-    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",
-                        message: "task 1",
-                        file: "test.ts",
-                        line: 1,
-                        column: 0,
-                    },
-                    {
-                        type: "FIXME",
-                        message: "bug 1",
-                        file: "test.ts",
-                        line: 2,
-                        column: 0,
-                    },
-                ],
-                byType: new Map([
-                    [
-                        "TODO",
-                        [
-                            {
-                                type: "TODO",
-                                message: "task 1",
-                                file: "test.ts",
-                                line: 1,
-                                column: 0,
-                            },
-                        ],
-                    ],
-                ]),
-                byFile: new Map([
-                    [
-                        "test.ts",
-                        [
-                            {
-                                type: "TODO",
-                                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",
-                        message: "bug",
-                        file: "test.ts",
-                        line: 2,
-                        column: 0,
-                    },
-                    {
-                        type: "TODO",
-                        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",
-                        message: "bug",
-                        file: "test.ts",
-                        line: 1,
-                        column: 0,
-                    },
-                    {
-                        type: "HACK",
-                        message: "hack",
-                        file: "test.ts",
-                        line: 2,
-                        column: 0,
-                    },
-                    {
-                        type: "BUG",
-                        message: "bug",
-                        file: "test.ts",
-                        line: 3,
-                        column: 0,
-                    },
-                    {
-                        type: "TODO",
-                        message: "todo",
-                        file: "test.ts",
-                        line: 4,
-                        column: 0,
-                    },
-                    {
-                        type: "NOTE",
-                        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
-        });
-    });
-});