pi-lens 3.1.2 → 3.2.0

package/clients/typescript-client.codefix.test.js

@@ -1,157 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-import { TypeScriptClient } from "./typescript-client.js";
-describe("TypeScriptClient - Code Fixes", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new TypeScriptClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-codefix-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("getCodeFixes", () => {
-        it("should provide fix for missing property on object literal", () => {
-            // Real-world case: Missing required property in object literal
-            const content = `
-interface Config {
-  name: string;
-  port: number;
-  debug: boolean;
-}
-
-const config: Config = {
-  name: "my-app",
-  port: 3000
-  // Missing 'debug' property - TS2345
-};
-`;
-            const filePath = createTempFile(tmpDir, "missing-property.ts", content);
-            client.addFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            const missingPropError = diags.find((d) => d.code === 2345 || d.message.includes("missing"));
-            if (missingPropError) {
-                const line = missingPropError.range.start.line;
-                const char = missingPropError.range.start.character;
-                const fixes = client.getCodeFixes(filePath, line, char, [
-                    missingPropError.code,
-                ]);
-                // TypeScript should suggest adding the missing property
-                expect(fixes.length).toBeGreaterThan(0);
-                const hasAddPropertyFix = fixes.some((f) => f.description.toLowerCase().includes("add") ||
-                    f.description.toLowerCase().includes("property") ||
-                    f.description.toLowerCase().includes("declare"));
-                expect(hasAddPropertyFix).toBe(true);
-            }
-        });
-        it("should provide fix for missing await in async function", () => {
-            // Real-world case: Forgetting await on a Promise-returning function
-            const content = `
-async function fetchUser(id: string): Promise<{ name: string }> {
-  return { name: "John" };
-}
-
-async function getUserName(id: string): Promise<string> {
-  const user = fetchUser(id); // Missing await
-  return user.name; // Type 'Promise<{ name: string; }>' has no property 'name'
-}
-`;
-            const filePath = createTempFile(tmpDir, "missing-await.ts", content);
-            client.addFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            // TS2739: Type 'Promise<{ name: string; }>' is missing 'name'
-            const propertyError = diags.find((d) => d.code === 2739 || d.message.includes("is missing"));
-            if (propertyError) {
-                const fixes = client.getAllCodeFixes(filePath);
-                // If there's an error, check if we have fixes for it
-                const lineFixes = fixes.get(propertyError.range.start.line);
-                if (lineFixes) {
-                    expect(lineFixes.length).toBeGreaterThan(0);
-                }
-            }
-            // Test passes if we get here - not all TS versions provide fixes for this
-            expect(true).toBe(true);
-        });
-        it("should provide fix for incorrect type assignment", () => {
-            // Real-world case: String instead of number
-            const content = `
-function calculateTotal(price: number, tax: number): number {
-  return price + tax;
-}
-
-const result = calculateTotal("100", 10); // TS2345: Argument of type 'string' is not assignable to parameter of type 'number'
-`;
-            const filePath = createTempFile(tmpDir, "type-mismatch.ts", content);
-            client.addFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            const typeError = diags.find((d) => d.code === 2345);
-            if (typeError) {
-                const line = typeError.range.start.line;
-                const char = typeError.range.start.character;
-                const fixes = client.getCodeFixes(filePath, line, char, [2345]);
-                // TypeScript often suggests fixes for type mismatches
-                expect(fixes).toBeDefined();
-            }
-        });
-        it("should collect all fixes via getAllCodeFixes", () => {
-            // Multiple errors in one file
-            const content = `
-interface Person {
-  name: string;
-  age: number;
-}
-
-const person: Person = {
-  name: "Alice"
-  // Missing age
-};
-
-function greet(p: Person): string {
-  return "Hello " + p.name;
-}
-
-greet({ name: "Bob" }); // Missing age in argument
-`;
-            const filePath = createTempFile(tmpDir, "multiple-errors.ts", content);
-            client.addFile(filePath, content);
-            const allFixes = client.getAllCodeFixes(filePath);
-            // Should have fixes mapped by line number
-            expect(allFixes).toBeInstanceOf(Map);
-            // Each fix entry should have a description and changes
-            for (const [line, fixes] of allFixes.entries()) {
-                expect(typeof line).toBe("number");
-                expect(fixes.length).toBeGreaterThan(0);
-                for (const fix of fixes) {
-                    expect(fix.description).toBeTruthy();
-                    expect(fix.changes).toBeDefined();
-                }
-            }
-        });
-    });
-    describe("Integration with diagnostic messages", () => {
-        it("should include fix suggestions in getAllCodeFixes output", () => {
-            const content = `
-class User {
-  constructor(public name: string) {}
-}
-
-const user = new User(); // TS2554: Expected 1 arguments, but got 0
-`;
-            const filePath = createTempFile(tmpDir, "constructor-args.ts", content);
-            client.addFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            const argError = diags.find((d) => d.code === 2554);
-            if (argError) {
-                const fixes = client.getAllCodeFixes(filePath);
-                const lineFixes = fixes.get(argError.range.start.line);
-                if (lineFixes && lineFixes.length > 0) {
-                    // The runner would append this to the message
-                    const suggestion = lineFixes[0].description;
-                    expect(suggestion).toBeTruthy();
-                }
-            }
-        });
-    });
-});

package/clients/typescript-client.test.js

@@ -1,105 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-import { TypeScriptClient } from "./typescript-client.js";
-describe("TypeScriptClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new TypeScriptClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ts-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isTypeScriptFile", () => {
-        it("should recognize TypeScript files", () => {
-            expect(client.isTypeScriptFile("test.ts")).toBe(true);
-            expect(client.isTypeScriptFile("test.tsx")).toBe(true);
-        });
-        it("should also recognize JavaScript files (for type checking)", () => {
-            expect(client.isTypeScriptFile("test.js")).toBe(true);
-            expect(client.isTypeScriptFile("test.jsx")).toBe(true);
-        });
-        it("should not recognize non-JS/TS files", () => {
-            expect(client.isTypeScriptFile("test.py")).toBe(false);
-            expect(client.isTypeScriptFile("test.md")).toBe(false);
-        });
-    });
-    describe("updateFile and getDiagnostics", () => {
-        it("should detect type errors", () => {
-            const content = `
-const x: number = "string"; // Type error
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            expect(diags.length).toBeGreaterThan(0);
-            expect(diags.some((d) => d.message.includes("string"))).toBe(true);
-        });
-        it("should not report errors for valid code", () => {
-            const content = `
-const x: number = 42;
-const y: string = "hello";
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            // May have warnings but no errors for valid code
-            const errors = diags.filter((d) => d.severity === 1); // Error severity
-            expect(errors.length).toBe(0);
-        });
-        it("should detect undefined variables", () => {
-            const content = `
-function test() {
-  return undefinedVariable;
-}
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            expect(diags.some((d) => d.message.includes("undefined"))).toBe(true);
-        });
-        it("should detect missing function arguments", () => {
-            const content = `
-function add(a: number, b: number): number {
-  return a + b;
-}
-const result = add(1);
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            expect(diags.some((d) => d.message.includes("Expected"))).toBe(true);
-        });
-    });
-    describe("diagnostic severity", () => {
-        it("should have correct severity levels", () => {
-            const diags = [
-                {
-                    range: {
-                        start: { line: 0, character: 0 },
-                        end: { line: 0, character: 10 },
-                    },
-                    severity: 1, // Error
-                    message: "Error message",
-                },
-                {
-                    range: {
-                        start: { line: 1, character: 0 },
-                        end: { line: 1, character: 10 },
-                    },
-                    severity: 2, // Warning
-                    message: "Warning message",
-                },
-            ];
-            // Test that diagnostics have expected structure
-            expect(diags[0].severity).toBe(1); // Error
-            expect(diags[1].severity).toBe(2); // Warning
-            expect(diags[0].message).toContain("Error");
-        });
-    });
-});

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

@@ -1,250 +0,0 @@
-/**
- * AstGrep Client for pi-lens
- *
- * Structural code analysis using ast-grep CLI.
- * Scans files against YAML rule definitions.
- *
- * Requires: npm install -D @ast-grep/cli
- * Rules: ./rules/ directory
- */
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { AstGrepParser } from "./ast-grep-parser.js";
-import { AstGrepRuleManager } from "./ast-grep-rule-manager.js";
-import { SgRunner } from "./sg-runner.js";
-const _getExtensionDir = () => {
-    if (typeof __dirname !== "undefined") {
-        return __dirname;
-    }
-    return ".";
-};
-// --- Client ---
-export class AstGrepClient {
-    available = null;
-    ruleDir;
-    log;
-    ruleManager;
-    runner;
-    constructor(ruleDir, verbose = false) {
-        this.ruleDir = ruleDir || path.join(process.cwd(), "rules");
-        this.log = verbose
-            ? (msg) => console.error(`[ast-grep] ${msg}`)
-            : () => { };
-        this.ruleManager = new AstGrepRuleManager(this.ruleDir, this.log);
-        this.runner = new SgRunner(verbose);
-    }
-    /**
-     * Check if ast-grep CLI is available
-     */
-    isAvailable() {
-        if (this.available !== null)
-            return this.available;
-        this.available = this.runner.isAvailable();
-        if (this.available) {
-            this.log("ast-grep available");
-        }
-        return this.available;
-    }
-    /**
-     * Search for AST patterns in files
-     */
-    async search(pattern, lang, paths, options) {
-        const args = ["run", "-p", pattern, "--lang", lang, "--json=compact"];
-        if (options?.selector) {
-            args.push("--selector", options.selector);
-        }
-        if (options?.context !== undefined) {
-            args.push("--context", String(options.context));
-        }
-        args.push(...paths);
-        return this.runner.exec(args);
-    }
-    /**
-     * Search and replace AST patterns
-     */
-    async replace(pattern, rewrite, lang, paths, apply = false) {
-        const args = [
-            "run",
-            "-p",
-            pattern,
-            "-r",
-            rewrite,
-            "--lang",
-            lang,
-            "--json=compact",
-        ];
-        if (apply)
-            args.push("--update-all");
-        args.push(...paths);
-        const result = await this.runner.exec(args);
-        return { matches: result.matches, applied: apply, error: result.error };
-    }
-    /**
-     * Run a one-off scan with a temporary rule and configuration
-     */
-    runTempScan(dir, ruleId, ruleYaml, timeout = 30000) {
-        if (!this.isAvailable())
-            return [];
-        return this.runner.tempScan(dir, ruleId, ruleYaml, timeout);
-    }
-    /**
-     * Find similar functions by comparing normalized AST structure
-     */
-    async findSimilarFunctions(dir, lang = "typescript") {
-        const ruleYaml = `id: find-functions
-language: ${lang}
-rule:
-  kind: function_declaration
-severity: info
-message: found
-`;
-        const matches = this.runTempScan(dir, "find-functions", ruleYaml);
-        if (matches.length === 0)
-            return [];
-        return this.groupSimilarFunctions(matches);
-    }
-    groupSimilarFunctions(matches) {
-        const grouped = new Map();
-        for (const item of matches) {
-            const name = this.extractFunctionName(item.text);
-            if (!name)
-                continue;
-            const signature = this.normalizeFunction(item.text);
-            const line = (item.range?.start?.line || item.labels?.[0]?.range?.start?.line || 0) +
-                1;
-            const group = grouped.get(signature) ?? [];
-            group.push({ name, file: item.file, line });
-            grouped.set(signature, group);
-        }
-        return Array.from(grouped.entries())
-            .filter(([_, functions]) => functions.length > 1)
-            .map(([pattern, functions]) => ({ pattern, functions }));
-    }
-    /**
-     * Extract function name from match text
-     */
-    extractFunctionName(text) {
-        return text.match(/function\s+(\w+)/)?.[1] ?? null;
-    }
-    normalizeFunction(text) {
-        const normalizedText = text
-            .replace(/function\s+\w+/, "function FN")
-            .replace(/\bconst\b|\blet\b|\bvar\b/g, "VAR")
-            .replace(/["'].*?["']/g, "STR")
-            .replace(/`[^`]*`/g, "TMPL")
-            .replace(/\b\d+\b/g, "NUM")
-            .replace(/\btrue\b|\bfalse\b/g, "BOOL")
-            .replace(/\/\/.*/g, "")
-            .replace(/\/\*[\s\S]*?\*\//g, "")
-            .replace(/\s+/g, " ")
-            .trim();
-        // Extract just the body structure
-        const bodyMatch = normalizedText.match(/\{(.*)\}/);
-        const body = bodyMatch ? bodyMatch[1].trim() : normalizedText;
-        // Use first 200 chars as signature
-        return body.slice(0, 200);
-    }
-    /**
-     * Scan for exported function names in a directory
-     */
-    async scanExports(dir, lang = "typescript") {
-        const exports = new Map();
-        const ruleYaml = `id: find-functions
-language: ${lang}
-rule:
-  kind: function_declaration
-severity: info
-message: found
-`;
-        const matches = this.runTempScan(dir, "find-functions", ruleYaml, 15000);
-        this.log(`scanExports output length: ${matches.length}`);
-        for (const item of matches) {
-            const text = item.text || "";
-            const nameMatch = text.match(/function\s+(\w+)/);
-            if (nameMatch?.[1]) {
-                this.log(`scanExports found: ${nameMatch[1]} in ${item.file}`);
-                exports.set(nameMatch[1], item.file);
-            }
-        }
-        return exports;
-    }
-    formatMatches(matches, isDryRun = false, showModeIndicator = false) {
-        return this.runner.formatMatches(matches, isDryRun, 50, showModeIndicator);
-    }
-    /**
-     * Scan a file against all rules
-     */
-    scanFile(filePath) {
-        if (!this.isAvailable())
-            return [];
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
-            return [];
-        const configPath = path.join(this.ruleDir, ".sgconfig.yml");
-        try {
-            const result = spawnSync("npx", ["sg", "scan", "--config", configPath, "--json", absolutePath], {
-                encoding: "utf-8",
-                timeout: 15000,
-                shell: process.platform === "win32",
-            });
-            // ast-grep exits 1 when it finds issues
-            const output = result.stdout || result.stderr || "";
-            if (!output.trim())
-                return [];
-            const parser = new AstGrepParser((id) => this.getRuleDescription(id), (sev) => this.mapSeverity(sev));
-            return parser.parseOutput(output, absolutePath);
-        }
-        catch (err) {
-            this.log(`Scan error: ${err instanceof Error ? err.message : String(err)}`);
-            return [];
-        }
-    }
-    /**
-     * Format diagnostics for LLM consumption
-     */
-    formatDiagnostics(diags) {
-        if (diags.length === 0)
-            return "";
-        const errors = diags.filter((d) => d.severity === "error");
-        const warnings = diags.filter((d) => d.severity === "warning");
-        const hints = diags.filter((d) => d.severity === "hint");
-        let output = `[ast-grep] ${diags.length} structural issue(s)`;
-        if (errors.length)
-            output += ` — ${errors.length} error(s)`;
-        if (warnings.length)
-            output += ` — ${warnings.length} warning(s)`;
-        if (hints.length)
-            output += ` — ${hints.length} hint(s)`;
-        output += ":\n";
-        for (const d of diags.slice(0, 10)) {
-            const loc = d.line === d.endLine ? `L${d.line}` : `L${d.line}-${d.endLine}`;
-            const ruleInfo = d.ruleDescription
-                ? `${d.rule}: ${d.ruleDescription.message}`
-                : d.rule;
-            const fix = d.fix || d.ruleDescription?.note ? " [fixable]" : "";
-            output += `  ${ruleInfo} (${loc})${fix}\n`;
-            if (d.ruleDescription?.note) {
-                const shortNote = d.ruleDescription.note.split("\n")[0];
-                output += `    → ${shortNote}\n`;
-            }
-        }
-        if (diags.length > 10) {
-            output += `  ... and ${diags.length - 10} more\n`;
-        }
-        return output;
-    }
-    getRuleDescription(ruleId) {
-        return this.ruleManager.loadRuleDescriptions().get(ruleId);
-    }
-    mapSeverity(severity) {
-        const lower = severity.toLowerCase();
-        if (lower === "error")
-            return "error";
-        if (lower === "warning")
-            return "warning";
-        if (lower === "info")
-            return "info";
-        return "hint";
-    }
-}

package/commands/clients/ast-grep-parser.js

@@ -1,86 +0,0 @@
-import * as path from "node:path";
-export class AstGrepParser {
-    getRuleDescription;
-    mapSeverity;
-    constructor(getRuleDescription, mapSeverity) {
-        this.getRuleDescription = getRuleDescription;
-        this.mapSeverity = mapSeverity;
-    }
-    parseOutput(output, filterFile) {
-        const resolvedFilterFile = path.resolve(filterFile);
-        try {
-            const items = JSON.parse(output);
-            if (Array.isArray(items)) {
-                return items
-                    .map((item) => this.parseDiagnostic(item, resolvedFilterFile))
-                    .filter((d) => d !== null);
-            }
-        }
-        catch (err) {
-            void err;
-        }
-        return output
-            .split("\n")
-            .filter((l) => l.trim())
-            .map((line) => {
-            try {
-                return this.parseDiagnostic(JSON.parse(line), resolvedFilterFile);
-            }
-            catch (err) {
-                void err;
-                return null;
-            }
-        })
-            .filter((d) => d !== null);
-    }
-    parseDiagnostic(item, filterFile) {
-        if (item.labels?.length) {
-            return this.parseNewFormat(item, filterFile);
-        }
-        if (item.spans?.length) {
-            return this.parseLegacyFormat(item, filterFile);
-        }
-        return null;
-    }
-    parseNewFormat(item, filterFile) {
-        const label = item.labels.find((l) => l.style === "primary") || item.labels[0];
-        const filePath = path.resolve(label.file || filterFile);
-        if (filePath !== filterFile)
-            return null;
-        const start = label.range?.start || { line: 0, column: 0 };
-        const end = label.range?.end || start;
-        return {
-            line: start.line + 1,
-            column: start.column,
-            endLine: end.line + 1,
-            endColumn: end.column,
-            severity: this.mapSeverity(item.severity),
-            message: item.message || "Unknown issue",
-            rule: item.ruleId || "unknown",
-            ruleDescription: this.getRuleDescription(item.ruleId || "unknown"),
-            file: filePath,
-        };
-    }
-    parseLegacyFormat(item, filterFile) {
-        const span = item.spans?.[0];
-        if (!span)
-            return null;
-        const filePath = path.resolve(span.file || filterFile);
-        if (filePath !== filterFile)
-            return null;
-        const start = span.range?.start || { line: 0, column: 0 };
-        const end = span.range?.end || start;
-        const ruleId = item.name || item.ruleId || "unknown";
-        return {
-            line: start.line + 1,
-            column: start.column,
-            endLine: end.line + 1,
-            endColumn: end.column,
-            severity: this.mapSeverity(item.severity || item.Severity || "warning"),
-            message: item.Message?.text || item.message || "Unknown issue",
-            rule: ruleId,
-            ruleDescription: this.getRuleDescription(ruleId),
-            file: filePath,
-        };
-    }
-}

package/commands/clients/ast-grep-rule-manager.js

@@ -1,91 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-export class AstGrepRuleManager {
-    ruleDir;
-    log;
-    ruleDescriptions = null;
-    constructor(ruleDir, log) {
-        this.ruleDir = ruleDir;
-        this.log = log;
-    }
-    loadRuleDescriptions() {
-        if (this.ruleDescriptions !== null)
-            return this.ruleDescriptions;
-        const descriptions = new Map();
-        const possiblePaths = [
-            path.join(this.ruleDir, "ast-grep-rules", "rules"),
-            path.join(this.ruleDir, "rules"),
-            this.ruleDir,
-        ];
-        const rulesPath = possiblePaths.find((p) => fs.existsSync(p));
-        if (!rulesPath) {
-            this.log(`Rule descriptions: no rules directory found in ${possiblePaths.join(", ")}`);
-            this.ruleDescriptions = descriptions;
-            return descriptions;
-        }
-        try {
-            const files = fs.readdirSync(rulesPath).filter((f) => f.endsWith(".yml"));
-            this.log(`Loaded ${files.length} rule descriptions from ${rulesPath}`);
-            for (const file of files) {
-                const filePath = path.join(rulesPath, file);
-                const content = fs.readFileSync(filePath, "utf-8");
-                const rule = this.parseRuleYaml(content);
-                if (rule) {
-                    descriptions.set(rule.id, rule);
-                }
-            }
-        }
-        catch (err) {
-            this.log(`Failed to load rule descriptions: ${err.message}`);
-        }
-        this.ruleDescriptions = descriptions;
-        return descriptions;
-    }
-    parseRuleYaml(content) {
-        const result = {};
-        const idMatch = content.match(/^id:\s*(.+)$/m);
-        if (idMatch)
-            result.id = idMatch[1].trim();
-        const msgMatch = content.match(/^message:\s*"([^"]+)"/m) ||
-            content.match(/^message:\s*'([^']+)'/m) ||
-            content.match(/^message:\s*(.+)$/m);
-        if (msgMatch)
-            result.message = (msgMatch[3] || msgMatch[2] || msgMatch[1]).trim();
-        const noteMatch = content.match(/^note:\s*\|([\s\S]*?)(?=^\w|\n\n|\nrule:)/m);
-        if (noteMatch) {
-            result.note = noteMatch[1]
-                .split("\n")
-                .map((line) => line.trim())
-                .filter((line) => line.length > 0)
-                .join(" ");
-        }
-        const sevMatch = content.match(/^severity:\s*(.+)$/m);
-        if (sevMatch)
-            result.severity = this.mapSeverity(sevMatch[1].trim());
-        const gradeMatch = content.match(/Grade\s+(\d+\.\d+)/i);
-        if (gradeMatch)
-            result.grade = parseFloat(gradeMatch[1]);
-        const fixMatch = content.match(/^fix:\s*\|?([\s\S]*?)(?=^\w|^rule:|Z)/m);
-        if (fixMatch) {
-            result.fix = fixMatch[1]
-                .split("\n")
-                .map((line) => line.replace(/^\s*\|?\s*/, ""))
-                .filter((line) => line.length > 0)
-                .join("\n");
-        }
-        if (result.id && result.message) {
-            return result;
-        }
-        return null;
-    }
-    mapSeverity(severity) {
-        const lower = severity.toLowerCase();
-        if (lower === "error")
-            return "error";
-        if (lower === "warning")
-            return "warning";
-        if (lower === "info")
-            return "info";
-        return "hint";
-    }
-}