pi-lens 3.6.2 → 3.6.4

package/clients/fix-scanners.js

@@ -1,204 +0,0 @@
-/**
- * Scanner functions for fix.ts
- *
- * Each scanner encapsulates one type of issue detection:
- * - scanDuplicates: JSCPD duplicate code detection
- * - scanDeadCode: Knip dead code detection
- * - scanAstGrep: Structural linting via ast-grep
- * - scanBiome: Remaining Biome lint issues
- * - scanSlop: AI slop indicators (high complexity patterns)
- */
-import * as nodeFs from "node:fs";
-import * as path from "node:path";
-import { EXCLUDED_DIRS } from "./file-utils.js";
-import { safeSpawn } from "./safe-spawn.js";
-import { shouldIgnoreFile } from "./scan-utils.js";
-const DEBUG_LOG = path.join(process.env.HOME || process.env.USERPROFILE || ".", "pi-lens-debug.log");
-function dbg(msg) {
-    const line = `[${new Date().toISOString()}] ${msg}\n`;
-    try {
-        nodeFs.appendFileSync(DEBUG_LOG, line);
-    }
-    catch (err) {
-        // Debug logging failed, silently ignore to avoid recursive errors
-        void err;
-    }
-}
-/**
- * Scan for duplicate code blocks using JSCPD
- */
-export function scanDuplicates(jscpd, targetPath, isTsProject) {
-    if (!jscpd.isAvailable())
-        return [];
-    const jscpdResult = jscpd.scan(targetPath);
-    return jscpdResult.clones.filter((c) => {
-        if (isTsProject && (c.fileA.endsWith(".js") || c.fileB.endsWith(".js")))
-            return false;
-        return path.resolve(c.fileA) !== path.resolve(c.fileB);
-    });
-}
-/**
- * Scan for dead code using Knip
- */
-export function scanDeadCode(knip, targetPath, isTsProject) {
-    if (!knip.isAvailable())
-        return [];
-    const knipResult = knip.analyze(targetPath);
-    return knipResult.issues.filter((i) => {
-        if (!i.file)
-            return true;
-        return !shouldIgnoreFile(i.file, isTsProject);
-    });
-}
-/**
- * Scan for structural issues using ast-grep
- */
-export function scanAstGrep(targetPath, isTsProject, configPath) {
-    const hasSg = nodeFs.existsSync(path.join(targetPath, "node_modules", ".bin", "sg")) ||
-        safeSpawn("npx", ["sg", "--version"], {
-            timeout: 5000,
-        }).status === 0;
-    if (!hasSg)
-        return [];
-    const result = safeSpawn("npx", [
-        "sg",
-        "scan",
-        "--config",
-        configPath,
-        "--json",
-        "--globs",
-        "!**/*.test.ts",
-        "--globs",
-        "!**/*.spec.ts",
-        "--globs",
-        "!**/test-utils.ts",
-        "--globs",
-        "!**/.pi-lens/**",
-        ...(isTsProject ? ["--globs", "!**/*.js"] : []),
-        targetPath,
-    ], {
-        timeout: 30000,
-    });
-    const raw = result.stdout?.trim() ?? "";
-    const items = raw.startsWith("[")
-        ? (() => {
-            try {
-                return JSON.parse(raw);
-            }
-            catch {
-                return [];
-            }
-        })()
-        : raw.split("\n").flatMap((l) => {
-            try {
-                return [JSON.parse(l)];
-            }
-            catch {
-                return [];
-            }
-        });
-    const astIssues = [];
-    for (const item of items) {
-        const rule = item.ruleId || item.rule?.title || item.name || "unknown";
-        const line = (item.labels?.[0]?.range?.start?.line ?? item.range?.start?.line ?? 0) +
-            1;
-        const relFile = path
-            .relative(targetPath, item.file ?? "")
-            .replace(/\\/g, "/");
-        if (shouldIgnoreFile(relFile, isTsProject))
-            continue;
-        astIssues.push({
-            rule,
-            file: relFile,
-            line,
-            message: item.message ?? rule,
-        });
-    }
-    return astIssues;
-}
-/**
- * Scan for remaining Biome lint issues (couldn't be auto-fixed)
- */
-export function scanBiomeIssues(biome, targetPath) {
-    if (!biome.isAvailable())
-        return [];
-    const checkResult = safeSpawn("npx", [
-        "@biomejs/biome",
-        "check",
-        "--reporter=json",
-        "--max-diagnostics=50",
-        targetPath,
-    ], { timeout: 20000 });
-    const remainingBiome = [];
-    try {
-        const data = JSON.parse(checkResult.stdout ?? "{}");
-        for (const diag of (data.diagnostics ?? []).slice(0, 20)) {
-            if (!diag.category?.startsWith("lint/"))
-                continue;
-            const filePath = diag.location?.path?.file ?? "";
-            const line = diag.location?.span?.start?.line ?? 0;
-            const rule = diag.category ?? "lint";
-            remainingBiome.push({
-                file: path.relative(targetPath, filePath).replace(/\\/g, "/"),
-                line: line + 1,
-                rule,
-                message: diag.message ?? rule,
-            });
-        }
-    }
-    catch (e) {
-        dbg(`biome lint parse failed: ${e}`);
-    }
-    return remainingBiome;
-}
-/**
- * Scan for AI slop indicators (high complexity patterns)
- */
-export function scanSlop(complexity, targetPath, isTsProject) {
-    const slopFiles = [];
-    const scanDir = (dir) => {
-        if (!nodeFs.existsSync(dir))
-            return;
-        for (const entry of nodeFs.readdirSync(dir, { withFileTypes: true })) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (EXCLUDED_DIRS.includes(entry.name))
-                    continue;
-                scanDir(fullPath);
-            }
-            else if (complexity.isSupportedFile(fullPath)) {
-                const metrics = complexity.analyzeFile(fullPath);
-                if (metrics) {
-                    const warnings = complexity
-                        .checkThresholds(metrics)
-                        .filter((w) => w.includes("AI-style") ||
-                        w.includes("try/catch") ||
-                        w.includes("single-use") ||
-                        w.includes("Excessive comments"));
-                    const relFile = path
-                        .relative(targetPath, fullPath)
-                        .replace(/\\/g, "/");
-                    if (shouldIgnoreFile(relFile, isTsProject))
-                        continue;
-                    if (warnings.length >= 2) {
-                        slopFiles.push({ file: relFile, warnings });
-                    }
-                }
-            }
-        }
-    };
-    scanDir(targetPath);
-    return slopFiles;
-}
-/**
- * Run all scanners and return combined results
- */
-export function scanAll(clients, targetPath, isTsProject, configPath) {
-    return {
-        duplicates: scanDuplicates(clients.jscpd, targetPath, isTsProject),
-        deadCode: scanDeadCode(clients.knip, targetPath, isTsProject),
-        astIssues: scanAstGrep(targetPath, isTsProject, configPath),
-        biomeIssues: scanBiomeIssues(clients.biome, targetPath),
-        slopFiles: scanSlop(clients.complexity, targetPath, isTsProject),
-    };
-}

package/clients/format-service.js

@@ -1,184 +0,0 @@
-/**
- * Format Service for pi-lens
- *
- * Concurrent formatter execution using Effect-TS.
- * Auto-formats files on write with multiple formatters per file.
- *
- * Key features:
- * - Auto-detects formatters based on project config
- * - Runs multiple formatters concurrently with concurrency limits
- * - FileTime integration for safety
- * - Multiple formatters per file (e.g., biome + prettier both run)
- */
-import * as path from "node:path";
-import { FileTime } from "./file-time.js";
-import { clearFormatterCache, formatFile, getFormattersForFile, } from "./formatters.js";
-// --- Configuration ---
-/** Maximum concurrent formatters to prevent resource contention */
-const DEFAULT_FORMATTER_CONCURRENCY = 2;
-// --- Format Service ---
-export class FormatService {
-    constructor(sessionID, enabled = true) {
-        this.fileTime = new FileTime(sessionID);
-        this.enabled = enabled;
-    }
-    /**
-     * Format a file with all detected formatters
-     * Runs formatters with limited concurrency to prevent resource contention
-     */
-    async formatFile(filePath, options = {}) {
-        const absolutePath = path.resolve(filePath);
-        const cwd = path.dirname(absolutePath);
-        // Skip if disabled
-        if (options.skip || !this.enabled) {
-            return {
-                filePath: absolutePath,
-                formatters: [],
-                anyChanged: false,
-                allSucceeded: true,
-            };
-        }
-        // Check if file was modified externally (safety check)
-        if (this.fileTime.hasChanged(absolutePath)) {
-            console.warn(`[format] File ${absolutePath} modified externally, skipping format`);
-            return {
-                filePath: absolutePath,
-                formatters: [],
-                anyChanged: false,
-                allSucceeded: false,
-            };
-        }
-        // Get formatters for this file
-        const formatters = options.formatters
-            ? await this.getFormattersByName(options.formatters)
-            : await getFormattersForFile(absolutePath, cwd);
-        if (formatters.length === 0) {
-            return {
-                filePath: absolutePath,
-                formatters: [],
-                anyChanged: false,
-                allSucceeded: true,
-            };
-        }
-        // Run formatters with limited concurrency
-        const results = await this.runFormattersWithConcurrency(absolutePath, formatters);
-        // Record new file state after formatting
-        this.fileTime.read(absolutePath);
-        // Build summary
-        const anyChanged = results.some((r) => r.changed);
-        const allSucceeded = results.every((r) => r.success);
-        return {
-            filePath: absolutePath,
-            formatters: results.map((r, i) => ({
-                name: formatters[i].name,
-                success: r.success,
-                changed: r.changed,
-                error: r.error,
-            })),
-            anyChanged,
-            allSucceeded,
-        };
-    }
-    /**
-     * Run formatters with limited concurrency to prevent resource contention
-     *
-     * Formatters are I/O bound so we can run 2-3 concurrently, but not unlimited.
-     * This prevents overwhelming the system when multiple formatters are configured.
-     */
-    async runFormattersWithConcurrency(filePath, formatters, concurrency = DEFAULT_FORMATTER_CONCURRENCY) {
-        const results = [];
-        // Process in batches to limit concurrent formatters
-        for (let i = 0; i < formatters.length; i += concurrency) {
-            const batch = formatters.slice(i, i + concurrency);
-            const batchResults = await Promise.all(batch.map(async (formatter) => {
-                try {
-                    // Add timeout to each formatter individually
-                    const timeoutMs = 30000;
-                    const timeoutPromise = new Promise((_, reject) => {
-                        setTimeout(() => reject(new Error(`Formatter ${formatter.name} timed out after ${timeoutMs}ms`)), timeoutMs);
-                    });
-                    return await Promise.race([
-                        formatFile(filePath, formatter),
-                        timeoutPromise,
-                    ]);
-                }
-                catch (error) {
-                    return {
-                        success: false,
-                        changed: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            }));
-            results.push(...batchResults);
-        }
-        return results;
-    }
-    /**
-     * Get formatters by name (for explicit formatter selection)
-     */
-    async getFormattersByName(names) {
-        const { listAllFormatters, ...formatters } = await import("./formatters.js");
-        const allNames = listAllFormatters();
-        return names
-            .filter((name) => allNames.includes(name))
-            .map((name) => {
-            // Access formatter by name from the exports
-            const key = `${name}Formatter`;
-            return formatters[key];
-        })
-            .filter(Boolean);
-    }
-    /**
-     * Assert file hasn't changed before editing
-     * Throws FileTimeError if file modified externally
-     */
-    assertUnchanged(filePath) {
-        this.fileTime.assert(filePath);
-    }
-    /**
-     * Check if file has changed externally
-     */
-    hasChanged(filePath) {
-        return this.fileTime.hasChanged(filePath);
-    }
-    /**
-     * Record file read (after agent reads file)
-     */
-    recordRead(filePath) {
-        this.fileTime.read(filePath);
-    }
-    /**
-     * Clear detection cache
-     */
-    clearCache() {
-        clearFormatterCache();
-    }
-}
-// --- Singleton Instance ---
-let globalFormatService = null;
-let currentSessionID = null;
-export function getFormatService(sessionID, enabled = true) {
-    // Create new instance if:
-    // 1. No service exists yet
-    // 2. Session ID changed (different session)
-    const shouldCreateNew = !globalFormatService || (sessionID && sessionID !== currentSessionID);
-    if (shouldCreateNew) {
-        globalFormatService = new FormatService(sessionID ?? "default", enabled);
-        currentSessionID = sessionID ?? "default";
-    }
-    return globalFormatService;
-}
-export function resetFormatService() {
-    globalFormatService = null;
-    currentSessionID = null;
-}
-/**
- * Reset format service and clear all file tracking state.
- * Use this in tests to ensure complete isolation.
- */
-export function clearFormatServiceAndFileState() {
-    resetFormatService();
-}
-// Re-export for convenience
-export { clearAllSessions } from "./file-time.js";