pi-lens 2.2.9 → 3.0.0

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

@@ -0,0 +1,250 @@
+/**
+ * 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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,91 @@
+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";
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Shared types for ast-grep client, parser, and rule manager.
+ *
+ * Extracted to prevent circular dependencies between:
+ * - ast-grep-client.ts
+ * - ast-grep-parser.ts
+ * - ast-grep-rule-manager.ts
+ */
+export {};