pi-lens 3.1.2 → 3.2.0

package/commands/clients/typescript-client.js

@@ -1,505 +0,0 @@
-/**
- * TypeScript Language Service Client for pi-local
- *
- * Uses TypeScript's in-process Language Service API for rich code intelligence.
- * This is lighter weight than spawning tsserver and provides the same features.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as ts from "typescript";
-// TypeScript file extensions
-const TS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
-// Default compiler options when no tsconfig is found
-/**
- * Build default CompilerOptions through TypeScript's own config parser so that
- * lib name → file path resolution works correctly in the Language Service.
- * Direct assignment of `lib: ["lib.es2020.d.ts"]` doesn't work because the
- * Language Service looks up those names relative to cwd, not the TS install dir.
- */
-function buildDefaultCompilerOptions() {
-    const fakeConfig = {
-        compilerOptions: {
-            target: "ES2020",
-            module: "ESNext",
-            moduleResolution: "bundler",
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            lib: ["es2020", "dom", "dom.iterable"],
-        },
-    };
-    const parsed = ts.parseJsonConfigFileContent(fakeConfig, ts.sys, process.cwd());
-    return { ...parsed.options, skipLibCheck: true };
-}
-const DEFAULT_COMPILER_OPTIONS = buildDefaultCompilerOptions();
-/**
- * Walk up from startDir until we find a tsconfig.json, or hit the fs root.
- */
-function findTsConfig(startDir) {
-    let dir = startDir;
-    while (true) {
-        const candidate = path.join(dir, "tsconfig.json");
-        if (fs.existsSync(candidate))
-            return candidate;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return null; // reached root
-        dir = parent;
-    }
-}
-/**
- * Read and parse a tsconfig.json, returning merged CompilerOptions.
- * Falls back to DEFAULT_COMPILER_OPTIONS on any error.
- */
-function loadCompilerOptions(tsconfigPath) {
-    try {
-        const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-        if (configFile.error)
-            return DEFAULT_COMPILER_OPTIONS;
-        const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(tsconfigPath));
-        if (parsed.errors.length)
-            return DEFAULT_COMPILER_OPTIONS;
-        // Always set skipLibCheck to avoid noise from node_modules
-        return { ...parsed.options, skipLibCheck: true };
-    }
-    catch (err) {
-        void err;
-        return DEFAULT_COMPILER_OPTIONS;
-    }
-}
-export class TypeScriptClient {
-    fileVersions = new Map();
-    fileContents = new Map();
-    languageService = null;
-    compilerOptions = DEFAULT_COMPILER_OPTIONS;
-    lastTsconfigDir = null;
-    constructor() {
-        this.initialize();
-    }
-    /**
-     * Normalize file path for consistent cross-platform use
-     */
-    normalizePath(filePath) {
-        return path.resolve(filePath).replace(/\\/g, "/");
-    }
-    /**
-     * Check if a file is a TypeScript/JavaScript file
-     */
-    isTypeScriptFile(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        return TS_EXTENSIONS.has(ext);
-    }
-    initialize() {
-        const host = {
-            getScriptFileNames: () => Array.from(this.fileContents.keys()),
-            getScriptVersion: (fileName) => {
-                const normalized = fileName.replace(/\\/g, "/");
-                return String(this.fileVersions.get(normalized) ?? 0);
-            },
-            getScriptSnapshot: (fileName) => {
-                const normalized = fileName.replace(/\\/g, "/");
-                const content = this.fileContents.get(normalized);
-                if (content)
-                    return ts.ScriptSnapshot.fromString(content);
-                try {
-                    return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName, "utf-8"));
-                }
-                catch {
-                    return undefined;
-                }
-            },
-            getCurrentDirectory: () => process.cwd(),
-            getCompilationSettings: () => this.compilerOptions,
-            getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
-            fileExists: (fileName) => ts.sys.fileExists(fileName),
-            readFile: (fileName) => {
-                const normalized = fileName.replace(/\\/g, "/");
-                const cached = this.fileContents.get(normalized);
-                if (cached !== undefined)
-                    return cached;
-                return ts.sys.readFile(fileName);
-            },
-            directoryExists: (dirName) => ts.sys.directoryExists(dirName),
-            getDirectories: (dir) => ts.sys.getDirectories(dir),
-        };
-        this.languageService = ts.createLanguageService(host, ts.createDocumentRegistry());
-    }
-    /**
-     * Detect tsconfig for the given file and refresh compilerOptions if the
-     * project root changed (avoids redundant re-parses across edits to the same project).
-     */
-    refreshCompilerOptions(filePath) {
-        const dir = path.dirname(path.resolve(filePath));
-        const tsconfigPath = findTsConfig(dir);
-        const key = tsconfigPath ?? dir;
-        if (key === this.lastTsconfigDir)
-            return; // same project, no change
-        this.lastTsconfigDir = key;
-        this.compilerOptions = tsconfigPath
-            ? loadCompilerOptions(tsconfigPath)
-            : DEFAULT_COMPILER_OPTIONS;
-    }
-    /**
-     * Add a file to the language service
-     */
-    addFile(filePath, content) {
-        const normalized = this.normalizePath(filePath);
-        this.fileContents.set(normalized, content);
-        this.fileVersions.set(normalized, (this.fileVersions.get(normalized) || 0) + 1);
-    }
-    /**
-     * Update a file's content — also refreshes compilerOptions if project changed
-     */
-    updateFile(filePath, content) {
-        this.refreshCompilerOptions(filePath);
-        const normalized = this.normalizePath(filePath);
-        this.fileVersions.set(normalized, (this.fileVersions.get(normalized) ?? 0) + 1);
-        this.fileContents.set(normalized, content);
-    }
-    /**
-     * Ensure a file is loaded from disk (refreshes cache)
-     */
-    ensureFile(filePath) {
-        const normalized = this.normalizePath(filePath);
-        try {
-            const diskContent = fs.readFileSync(filePath, "utf-8");
-            const cachedContent = this.fileContents.get(normalized);
-            if (cachedContent !== diskContent) {
-                this.updateFile(filePath, diskContent);
-            }
-        }
-        catch (err) {
-            void err;
-        }
-    }
-    /**
-     * Get all tracked files
-     */
-    getTrackedFiles() {
-        return Array.from(this.fileContents.keys());
-    }
-    /**
-     * Convert line/character to position offset
-     */
-    lineCharToPosition(content, line, character) {
-        const lines = content.split("\n");
-        let position = 0;
-        for (let i = 0; i < Math.min(line, lines.length); i++) {
-            position += lines[i].length + 1;
-        }
-        return position + character;
-    }
-    /**
-     * Get diagnostics (errors and warnings) for a file
-     */
-    getDiagnostics(filePath) {
-        this.refreshCompilerOptions(filePath);
-        const normalized = this.normalizePath(filePath);
-        this.ensureFile(filePath);
-        if (!this.languageService)
-            return [];
-        const syntactic = this.languageService.getSyntacticDiagnostics(normalized);
-        const semantic = this.languageService.getSemanticDiagnostics(normalized);
-        return ([...syntactic, ...semantic]
-            .filter((diag) => diag.file && diag.start !== undefined)
-            // Filter cross-file "redeclare" noise — happens when non-module scripts
-            // share global scope across multiple tracked files (TS2300, TS2451)
-            .filter((diag) => {
-            if (diag.code !== 2300 && diag.code !== 2451)
-                return true;
-            // Only keep if the related information points back to the same file
-            const related = diag.relatedInformation ?? [];
-            return related.every((r) => !r.file || this.normalizePath(r.file.fileName) === normalized);
-        })
-            .map((diag) => {
-            const startPos = diag.file?.getLineAndCharacterOfPosition(diag.start);
-            const endPos = diag.file?.getLineAndCharacterOfPosition(diag.start + diag.length);
-            return {
-                range: {
-                    start: { line: startPos.line, character: startPos.character },
-                    end: { line: endPos.line, character: endPos.character },
-                },
-                severity: (diag.category === ts.DiagnosticCategory.Error
-                    ? 1
-                    : 2),
-                code: diag.code,
-                message: ts.flattenDiagnosticMessageText(diag.messageText, "\n"),
-                source: "typescript",
-            };
-        }));
-    }
-    /**
-     * Get hover information at a position
-     */
-    getHover(filePath, line, character) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return null;
-        const { normalized, position, ls } = resolved;
-        const info = ls.getQuickInfoAtPosition(normalized, position);
-        if (!info)
-            return null;
-        return {
-            type: ts.displayPartsToString(info.displayParts),
-            documentation: info.documentation
-                ? ts.displayPartsToString(info.documentation)
-                : undefined,
-        };
-    }
-    /**
-     * Shared preamble for position-based LSP queries.
-     * Returns null if prerequisites are not met.
-     */
-    resolvePosition(filePath, line, character) {
-        const normalized = this.normalizePath(filePath);
-        this.ensureFile(filePath);
-        if (!this.languageService)
-            return null;
-        const content = this.fileContents.get(normalized);
-        if (!content)
-            return null;
-        return {
-            normalized,
-            position: this.lineCharToPosition(content, line, character),
-            ls: this.languageService,
-        };
-    }
-    withPosition(filePath, line, character, cb) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return [];
-        const { normalized, position, ls } = resolved;
-        return cb(normalized, position, ls) ?? [];
-    }
-    /**
-     * Go to definition
-     */
-    getDefinition(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const definitions = ls.getDefinitionAtPosition(normalized, position);
-            if (!definitions)
-                return undefined;
-            return definitions.map((def) => {
-                if (def.textSpan) {
-                    const defFile = def.fileName || normalized;
-                    const defContent = this.fileContents.get(defFile) || "";
-                    if (defContent) {
-                        const lines = defContent
-                            .substring(0, def.textSpan.start)
-                            .split("\n");
-                        return {
-                            file: defFile,
-                            line: lines.length - 1,
-                            character: lines[lines.length - 1].length,
-                        };
-                    }
-                }
-                return { file: def.fileName, line: 0, character: 0 };
-            });
-        });
-    }
-    /**
-     * Get type definition
-     */
-    getTypeDefinition(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const defs = ls.getTypeDefinitionAtPosition(normalized, position);
-            if (!defs)
-                return undefined;
-            return this.toLocations(defs, normalized);
-        });
-    }
-    /**
-     * Find references
-     */
-    getReferences(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const references = ls.getReferencesAtPosition(normalized, position);
-            if (!references)
-                return undefined;
-            return this.toLocations(references);
-        });
-    }
-    /** Map TS definition/reference entries to Location objects. */
-    toLocations(entries, fallbackFile) {
-        return entries.map((e) => ({
-            file: e.fileName || fallbackFile || "",
-            line: 0,
-            character: 0,
-        }));
-    }
-    /**
-     * Shared preamble for tree-based LSP queries (symbols, folding).
-     */
-    resolveTree(filePath) {
-        const normalized = this.normalizePath(filePath);
-        this.ensureFile(filePath);
-        if (!this.languageService)
-            return null;
-        const tree = this.languageService.getNavigationTree(normalized);
-        if (!tree)
-            return null;
-        return { normalized, tree };
-    }
-    /**
-     * Get document symbols
-     */
-    getSymbols(filePath) {
-        const resolved = this.resolveTree(filePath);
-        if (!resolved)
-            return [];
-        const { tree } = resolved;
-        const symbols = [];
-        const extract = (node, container) => {
-            if (node.span) {
-                symbols.push({
-                    name: node.text,
-                    kind: this.symbolKind(node.kind),
-                    line: 0,
-                    containerName: container,
-                });
-            }
-            if (node.childItems) {
-                for (const child of node.childItems) {
-                    extract(child, node.text);
-                }
-            }
-        };
-        extract(tree);
-        return symbols;
-    }
-    /**
-     * Get completions at a position
-     */
-    getCompletions(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const completions = ls.getCompletionsAtPosition(normalized, position, {});
-            if (!completions)
-                return undefined;
-            return completions.entries.slice(0, 50).map((entry) => ({
-                name: entry.name,
-                kind: this.completionKind(entry.kind),
-                sortText: entry.sortText,
-            }));
-        });
-    }
-    /**
-     * Go to implementation
-     */
-    getImplementation(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const implementations = ls.getImplementationAtPosition(normalized, position);
-            if (!implementations)
-                return undefined;
-            return this.toLocations(implementations);
-        });
-    }
-    /**
-     * Get folding ranges
-     */
-    getFoldingRanges(filePath) {
-        const resolved = this.resolveTree(filePath);
-        if (!resolved)
-            return [];
-        const { tree } = resolved;
-        const ranges = [];
-        const findFolds = (node) => {
-            if (!node?.span)
-                return;
-            if (node.kind === "function" || node.kind === "class") {
-                ranges.push({
-                    startLine: 0,
-                    endLine: 0,
-                    kind: node.kind,
-                });
-            }
-            if (node.childItems) {
-                for (const child of node.childItems) {
-                    findFolds(child);
-                }
-            }
-        };
-        findFolds(tree);
-        return ranges;
-    }
-    /**
-     * Explain an error at a specific line
-     */
-    explainError(filePath, line) {
-        const diagnostics = this.getDiagnostics(filePath);
-        const errorAtLine = diagnostics.find((d) => d.range.start.line === line && d.severity === 1);
-        if (!errorAtLine)
-            return null;
-        return { message: errorAtLine.message, code: errorAtLine.code };
-    }
-    /**
-     * Get quick fixes (code actions) for a diagnostic at a position.
-     * Returns array of fix descriptions with their edit changes.
-     */
-    getCodeFixes(filePath, line, character, errorCodes) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return [];
-        const { normalized, position, ls } = resolved;
-        const formatOpts = {
-            indentSize: 2,
-            tabSize: 2,
-            newLineCharacter: "\n",
-            convertTabsToSpaces: true,
-        };
-        const fixes = ls.getCodeFixesAtPosition(normalized, position, position, errorCodes, formatOpts, {});
-        if (!fixes)
-            return [];
-        return fixes.map((fix) => ({
-            description: fix.description,
-            changes: fix.changes?.map((change) => ({
-                fileName: change.fileName,
-                textChanges: change.textChanges,
-            })) || [],
-        }));
-    }
-    /**
-     * Get all quick fixes for all diagnostics in a file.
-     * Returns a map of diagnostic line → fixes.
-     */
-    getAllCodeFixes(filePath) {
-        const fixesByLine = new Map();
-        const diagnostics = this.getDiagnostics(filePath);
-        for (const diag of diagnostics) {
-            if (diag.severity !== 1 || diag.code === undefined)
-                continue;
-            const fixes = this.getCodeFixes(filePath, diag.range.start.line, diag.range.start.character, [diag.code]);
-            if (fixes.length > 0) {
-                fixesByLine.set(diag.range.start.line, fixes);
-            }
-        }
-        return fixesByLine;
-    }
-    symbolKind(kind) {
-        const map = {
-            script: "file",
-            class: "class",
-            interface: "interface",
-            function: "function",
-            method: "method",
-            property: "property",
-            variable: "variable",
-            enum: "enum",
-            module: "module",
-        };
-        return map[kind] || "unknown";
-    }
-    completionKind(kind) {
-        const map = {
-            property: "property",
-            method: "method",
-            class: "class",
-            interface: "interface",
-            enum: "enum",
-            variable: "variable",
-            function: "function",
-            keyword: "keyword",
-        };
-        return map[kind] || "text";
-    }
-}

package/commands/rate.test.js

@@ -1,119 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatRateResult } from "./rate.js";
-// Test the formatting functions directly with mock data
-describe("formatRateResult", () => {
-    it("should format a visual score breakdown", () => {
-        const result = {
-            overall: 75,
-            categories: [
-                { name: "Type Safety", score: 85, icon: "🔷", issues: [] },
-                { name: "Complexity", score: 70, icon: "🧩", issues: [] },
-                { name: "Security", score: 100, icon: "🔒", issues: [] },
-                { name: "Architecture", score: 85, icon: "🏗️", issues: [] },
-                { name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
-                { name: "Tests", score: 100, icon: "✅", issues: [] },
-            ],
-        };
-        const output = formatRateResult(result);
-        expect(output).toContain("CODE QUALITY SCORE");
-        expect(output).toContain("75/100");
-        expect(output).toContain("Type Safety");
-        expect(output).toContain("Security");
-        expect(output).toContain("Tests");
-    });
-    it("should show correct grade for A", () => {
-        const result = {
-            overall: 95,
-            categories: Array(6).fill({
-                name: "Test",
-                score: 95,
-                icon: "✅",
-                issues: [],
-            }),
-        };
-        const output = formatRateResult(result);
-        expect(output).toContain("A");
-    });
-    it("should show correct grade for B", () => {
-        const result = {
-            overall: 85,
-            categories: Array(6).fill({
-                name: "Test",
-                score: 85,
-                icon: "✅",
-                issues: [],
-            }),
-        };
-        const output = formatRateResult(result);
-        expect(output).toContain("B");
-    });
-    it("should show correct grade for C", () => {
-        const result = {
-            overall: 75,
-            categories: Array(6).fill({
-                name: "Test",
-                score: 75,
-                icon: "✅",
-                issues: [],
-            }),
-        };
-        const output = formatRateResult(result);
-        expect(output).toContain("C");
-    });
-    it("should show issues section when there are problems", () => {
-        const result = {
-            overall: 50,
-            categories: [
-                {
-                    name: "Type Safety",
-                    score: 50,
-                    icon: "🔷",
-                    issues: ["50 untyped identifiers"],
-                },
-                {
-                    name: "Complexity",
-                    score: 50,
-                    icon: "🧩",
-                    issues: ["High complexity: foo.ts"],
-                },
-                { name: "Security", score: 100, icon: "🔒", issues: [] },
-                { name: "Architecture", score: 100, icon: "🏗️", issues: [] },
-                { name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
-                { name: "Tests", score: 100, icon: "✅", issues: [] },
-            ],
-        };
-        const output = formatRateResult(result);
-        expect(output).toContain("Issues to address");
-        expect(output).toContain("Type Safety");
-        expect(output).toContain("/lens-booboo");
-    });
-    it("should not show issues section when clean", () => {
-        const result = {
-            overall: 100,
-            categories: Array(6).fill({
-                name: "Test",
-                score: 100,
-                icon: "✅",
-                issues: [],
-            }),
-        };
-        const output = formatRateResult(result);
-        expect(output).not.toContain("Issues to address");
-    });
-    it("should use colored bars based on score", () => {
-        const resultHigh = {
-            overall: 90,
-            categories: [{ name: "Test", score: 85, icon: "✅", issues: [] }],
-        };
-        const resultLow = {
-            overall: 50,
-            categories: [{ name: "Test", score: 50, icon: "✅", issues: [] }],
-        };
-        const outputHigh = formatRateResult(resultHigh);
-        const outputLow = formatRateResult(resultLow);
-        // High score should have green squares
-        expect(outputHigh).toContain("🟩");
-        // Low score should have red squares
-        expect(outputLow).toContain("🟥");
-    });
-});

package/rules/ast-grep-rules/rules/no-dangerously-set-inner-html.yml

@@ -1,13 +0,0 @@
-id: no-dangerously-set-inner-html
-language: TSX
-message: "dangerouslySetInnerHTML can expose XSS vulnerabilities — sanitize with DOMPurify"
-severity: error
-note: |
-  dangerouslySetInnerHTML bypasses React's escaping and can introduce
-  XSS if the content is user-controlled. Always sanitize with DOMPurify
-  or similar library before rendering.
-rule:
-  kind: jsx_attribute
-  has:
-    field: attribute
-    regex: "^dangerouslySetInnerHTML$"

package/rules/ast-grep-rules/rules/no-debugger.yml

@@ -1,12 +0,0 @@
-id: no-debugger
-message: Unexpected `debugger` statement.
-severity: error
-language: TypeScript
-rule:
-  pattern: debugger
-note: |
-  Production code should definitely not contain debugger, as it will cause the browser to stop executing code and open an appropriate debugger.
-
-url: https://eslint.org/docs/rules/no-debugger
-
-fix: ""  # Remove the debugger statement

package/rules/ast-grep-rules/rules/no-eval.yml

@@ -1,13 +0,0 @@
-id: no-eval
-language: TypeScript
-message: "Avoid eval() — it can execute arbitrary code and is a security risk"
-severity: error
-note: |
-  eval() executes strings as code which can lead to security vulnerabilities
-  and performance issues. Use safer alternatives like JSON.parse() for data.
-  Grade 3.5 — high risk, critical security issue.
-rule:
-  any:
-    - pattern: eval($$$ARGS)
-    - pattern: window.eval($$$ARGS)
-    - pattern: global.eval($$$ARGS)