pi-lens 3.6.2 → 3.6.4

package/clients/architect-client.js

@@ -1,291 +0,0 @@
-/**
- * Architect Client for pi-lens
- *
- * Loads path-based architectural rules from .pi-lens/architect.yaml
- * and checks file paths against them.
- *
- * Provides:
- * - Pre-write hints: what rules apply before the agent edits
- * - Post-write validation: check for violations after edits
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { minimatch } from "minimatch";
-// --- Client ---
-export class ArchitectClient {
-    constructor(verbose = false) {
-        this.config = null;
-        this.isUserConfig = false;
-        this.log = verbose
-            ? (msg) => console.error(`[architect] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Load architect config from project root.
-     * Falls back to built-in default if no user config exists.
-     */
-    loadConfig(projectRoot) {
-        // Try user config locations first
-        const userCandidates = [
-            path.join(projectRoot, ".pi-lens", "architect.yaml"),
-            path.join(projectRoot, "architect.yaml"),
-            path.join(projectRoot, ".pi-lens", "architect.yml"),
-        ];
-        for (const configPath of userCandidates) {
-            try {
-                const content = fs.readFileSync(configPath, "utf-8");
-                this.config = this.parseYaml(content);
-                this.configPath = configPath;
-                this.isUserConfig = true;
-                this.log(`Loaded user architect config from ${configPath}`);
-                return true;
-            }
-            catch (error) {
-                this.log(`Could not read ${configPath}: ${error}`);
-            }
-        }
-        // Fall back to built-in default
-        try {
-            // Try multiple possible locations for the default config
-            const possibleDefaultPaths = [
-                path.join(projectRoot, "default-architect.yaml"),
-                path.join(projectRoot, "..", "default-architect.yaml"),
-                path.join(process.cwd(), "default-architect.yaml"),
-            ];
-            // Handle both CommonJS and ESM environments
-            if (typeof __dirname !== "undefined") {
-                possibleDefaultPaths.push(path.join(__dirname, "..", "default-architect.yaml"));
-                possibleDefaultPaths.push(path.join(__dirname, "..", "..", "default-architect.yaml"));
-            }
-            for (const defaultPath of possibleDefaultPaths) {
-                try {
-                    const content = fs.readFileSync(defaultPath, "utf-8");
-                    this.config = this.parseYaml(content);
-                    this.configPath = defaultPath;
-                    this.isUserConfig = false;
-                    this.log("Using default architect rules (create .pi-lens/architect.yaml to customize)");
-                    return true;
-                }
-                catch {
-                    // Try next path
-                }
-            }
-            this.log("No architect config available");
-            return false;
-        }
-        catch {
-            this.log("No architect config available");
-            return false;
-        }
-    }
-    /**
-     * Check if the loaded config is user-defined (not default)
-     */
-    isUserDefined() {
-        return this.isUserConfig;
-    }
-    /**
-     * Check if config is loaded
-     */
-    hasConfig() {
-        return this.config !== null;
-    }
-    /**
-     * Get rules that apply to a file path
-     */
-    getRulesForFile(filePath) {
-        if (!this.config)
-            return [];
-        const matched = [];
-        for (const rule of this.config.rules) {
-            if (minimatch(filePath, rule.pattern, { matchBase: true })) {
-                matched.push(rule);
-            }
-        }
-        return matched;
-    }
-    /**
-     * Check code content against rules for a file path
-     * Returns violations found
-     */
-    checkFile(filePath, content) {
-        const rules = this.getRulesForFile(filePath);
-        const violations = [];
-        for (const rule of rules) {
-            if (!rule.must_not)
-                continue;
-            for (const check of rule.must_not) {
-                // We use 'g' to find all occurrences and correctly report line numbers
-                const regex = new RegExp(check.pattern, "gi");
-                let match;
-                // biome-ignore lint/suspicious/noAssignInExpressions: RegExp.exec iteration
-                while ((match = regex.exec(content)) !== null) {
-                    // Convert index to line number
-                    const lineNum = content.slice(0, match.index).split("\n").length;
-                    violations.push({
-                        pattern: rule.pattern,
-                        message: check.message,
-                        line: lineNum,
-                        fix: check.fix,
-                        note: check.note,
-                    });
-                    // Prevent infinite loop on empty matches
-                    if (match.index === regex.lastIndex) {
-                        regex.lastIndex++;
-                    }
-                }
-            }
-        }
-        return violations;
-    }
-    /**
-     * Check file size against max_lines rule
-     * Returns violation if file exceeds the limit
-     */
-    checkFileSize(filePath, lineCount) {
-        const rules = this.getRulesForFile(filePath);
-        for (const rule of rules) {
-            if (rule.max_lines && lineCount > rule.max_lines) {
-                return {
-                    pattern: rule.pattern,
-                    message: `File is ${lineCount} lines — exceeds ${rule.max_lines} line limit. Split into smaller modules.`,
-                };
-            }
-        }
-        return null;
-    }
-    /**
-     * Get pre-write hints for a file path
-     * Returns rules that will apply to the file being written
-     */
-    getHints(filePath) {
-        const rules = this.getRulesForFile(filePath);
-        const hints = [];
-        for (const rule of rules) {
-            if (rule.must_not) {
-                for (const check of rule.must_not) {
-                    hints.push(check.message);
-                }
-            }
-            if (rule.must) {
-                for (const req of rule.must) {
-                    hints.push(`Must: ${req}`);
-                }
-            }
-        }
-        return hints;
-    }
-    /**
-     * Simple YAML parser for architect.yaml format
-     * Handles the specific structure we need
-     */
-    parseYaml(content) {
-        const config = { rules: [] };
-        // Split into top-level rule blocks (4-space indent "- pattern:")
-        const ruleBlocks = content.split(/(?=^ {2}- pattern:)/m);
-        for (const block of ruleBlocks) {
-            const lines = block.split("\n");
-            let rule = null;
-            let section = null;
-            let violation = null;
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (trimmed.startsWith("#") || !trimmed)
-                    continue;
-                // Version (top-level)
-                if (trimmed.startsWith("version:") && !rule) {
-                    config.version = trimmed.split(":")[1]?.trim().replace(/['"]/g, "");
-                    continue;
-                }
-                // Rule pattern
-                const ruleMatch = trimmed.match(/^-?\s*pattern:\s*["'](.+?)["']/);
-                if (ruleMatch && trimmed.startsWith("-") && !section) {
-                    rule = { pattern: ruleMatch[1], must_not: [], must: [] };
-                    continue;
-                }
-                // Nested pattern inside must_not (may start with "- ")
-                if ((trimmed.startsWith("pattern:") ||
-                    trimmed.startsWith("- pattern:")) &&
-                    section === "must_not") {
-                    // Extract everything after "pattern:" and unquote
-                    const raw = trimmed.replace(/^-?\s*pattern:\s*/, "").trim();
-                    const unquoted = raw.replace(/^["']|["']$/g, "");
-                    if (unquoted) {
-                        violation = { pattern: unquoted, message: "" };
-                    }
-                    continue;
-                }
-                // Section headers
-                if (trimmed === "must_not:" || trimmed.startsWith("must_not:")) {
-                    section = "must_not";
-                    continue;
-                }
-                if (trimmed === "must:") {
-                    section = "must";
-                    continue;
-                }
-                // Message for current violation (handle nested quotes)
-                if (trimmed.startsWith("message:") && violation) {
-                    // Match "..." or '...' allowing the other quote type inside
-                    const dquoteMatch = trimmed.match(/message:\s*"([^"]*)"/);
-                    const squoteMatch = !dquoteMatch
-                        ? trimmed.match(/message:\s*'([^']*)'/)
-                        : null;
-                    const match = dquoteMatch || squoteMatch;
-                    if (match) {
-                        violation.message = match[1];
-                        if (rule) {
-                            rule.must_not = rule.must_not ?? [];
-                            rule.must_not.push(violation);
-                        }
-                        violation = null;
-                    }
-                    continue;
-                }
-                // Fix guidance for current violation
-                if (trimmed.startsWith("fix:") && violation) {
-                    const dquoteMatch = trimmed.match(/fix:\s*"([^"]*)"/);
-                    const squoteMatch = !dquoteMatch
-                        ? trimmed.match(/fix:\s*'([^']*)'/)
-                        : null;
-                    const match = dquoteMatch || squoteMatch;
-                    if (match) {
-                        violation.fix = match[1];
-                    }
-                    continue;
-                }
-                // Note guidance for current violation
-                if (trimmed.startsWith("note:") && violation) {
-                    const dquoteMatch = trimmed.match(/note:\s*"([^"]*)"/);
-                    const squoteMatch = !dquoteMatch
-                        ? trimmed.match(/note:\s*'([^']*)'/)
-                        : null;
-                    const match = dquoteMatch || squoteMatch;
-                    if (match) {
-                        violation.note = match[1];
-                    }
-                    continue;
-                }
-                // Must items (simple strings)
-                if (section === "must" && trimmed.startsWith("- ") && rule) {
-                    const item = trimmed.slice(2).replace(/^["']|["']$/g, "");
-                    rule.must = rule.must ?? [];
-                    rule.must.push(item);
-                }
-                // max_lines setting
-                if (trimmed.startsWith("max_lines:") && rule) {
-                    const num = parseInt(trimmed.split(":")[1]?.trim(), 10);
-                    if (!Number.isNaN(num)) {
-                        rule.max_lines = num;
-                    }
-                }
-            }
-            if (rule) {
-                config.rules.push(rule);
-            }
-        }
-        return config;
-    }
-}
-// --- Singleton ---
-const _instance = null;

package/clients/ast-grep-client.js

@@ -1,253 +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 {
-    constructor(ruleDir, verbose = false) {
-        this.available = null;
-        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, auto-install if not
-     */
-    async ensureAvailable() {
-        return this.runner.ensureAvailable();
-    }
-    /**
-     * Check if ast-grep CLI is available (legacy sync method)
-     * Prefer ensureAvailable() for auto-install behavior
-     */
-    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/clients/ast-grep-parser.js

@@ -1,84 +0,0 @@
-import * as path from "node:path";
-export class AstGrepParser {
-    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,
-        };
-    }
-}