pi-lens 3.6.2 → 3.6.4

package/clients/safe-spawn-async.js

@@ -1,163 +0,0 @@
-/**
- * Safe async cross-platform spawn utilities
- *
- * Replaces blocking spawnSync with async spawn + proper timeout handling.
- * Ensures processes are killed on timeout to prevent zombie processes.
- */
-import { spawn } from "node:child_process";
-/**
- * Async spawn with timeout and proper process cleanup.
- *
- * Unlike spawnSync, this:
- * - Doesn't block the event loop
- * - Kills the process on timeout (preventing zombies)
- * - Supports cancellation via AbortSignal
- */
-export async function safeSpawnAsync(command, args, options) {
-    const timeout = options?.timeout ?? 30000;
-    const abortSignal = options?.signal;
-    return new Promise((resolve) => {
-        // Check for early abort
-        if (abortSignal?.aborted) {
-            resolve({
-                stdout: "",
-                stderr: "",
-                status: null,
-                error: new Error("Spawn aborted before start"),
-            });
-            return;
-        }
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        // Spawn the process (non-blocking)
-        const child = spawn(command, args, {
-            cwd: options?.cwd,
-            env: options?.env,
-            windowsHide: true,
-            shell: false, // Always use args array (safer, no shell injection)
-        });
-        // Handle abort signal
-        const onAbort = () => {
-            if (!child.killed) {
-                child.kill("SIGTERM");
-                // Force kill after 1s if still running
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill("SIGKILL");
-                    }
-                }, 1000);
-            }
-        };
-        abortSignal?.addEventListener("abort", onAbort, { once: true });
-        // Collect output
-        child.stdout?.setEncoding("utf-8");
-        child.stderr?.setEncoding("utf-8");
-        child.stdout?.on("data", (data) => (stdout += data));
-        child.stderr?.on("data", (data) => (stderr += data));
-        // Timeout handling - KILL the process, don't just abandon it
-        const timeoutId = setTimeout(() => {
-            timedOut = true;
-            if (!child.killed) {
-                child.kill("SIGTERM");
-                // Force kill after 1s grace period
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill("SIGKILL");
-                    }
-                }, 1000);
-            }
-        }, timeout);
-        // Process completion
-        child.on("close", (code, signal) => {
-            clearTimeout(timeoutId);
-            abortSignal?.removeEventListener("abort", onAbort);
-            if (timedOut) {
-                resolve({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: new Error(`Process timed out after ${timeout}ms (signal: ${signal || "none"})`),
-                });
-            }
-            else if (signal) {
-                resolve({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: new Error(`Process killed by signal: ${signal}`),
-                });
-            }
-            else {
-                resolve({ stdout, stderr, status: code });
-            }
-        });
-        child.on("error", (err) => {
-            clearTimeout(timeoutId);
-            abortSignal?.removeEventListener("abort", onAbort);
-            resolve({ stdout, stderr, status: null, error: err });
-        });
-    });
-}
-/**
- * Backward-compatible wrapper - for gradual migration.
- *
- * ⚠️ Deprecated: Use safeSpawnAsync instead to avoid blocking.
- * This maintains the old signature but internally uses async spawn.
- */
-export function safeSpawn(command, args, options) {
-    // For now, keep the old behavior during migration
-    // We'll replace callers gradually to avoid breaking changes
-    const { spawnSync } = require("node:child_process");
-    const result = spawnSync(command, args, {
-        cwd: options?.cwd,
-        env: options?.env,
-        timeout: options?.timeout,
-        encoding: "utf-8",
-        shell: false,
-        windowsHide: true,
-        // Windows-specific: kill tree on timeout
-        killSignal: process.platform === "win32" ? "SIGTERM" : undefined,
-    });
-    return {
-        stdout: result.stdout?.toString() || "",
-        stderr: result.stderr?.toString() || "",
-        status: result.status,
-        error: result.error,
-    };
-}
-/**
- * Check if a command is available in PATH (async version)
- */
-export async function isCommandAvailableAsync(command) {
-    const finder = process.platform === "win32" ? "where" : "which";
-    const result = await safeSpawnAsync(finder, [command], { timeout: 5000 });
-    return result.status === 0 && !result.error;
-}
-/**
- * Find the full path to a command (async version)
- */
-export async function findCommandAsync(command) {
-    const finder = process.platform === "win32" ? "where" : "which";
-    const result = await safeSpawnAsync(finder, [command], { timeout: 5000 });
-    if (result.status !== 0 || result.error)
-        return null;
-    // Take first line (first match)
-    return result.stdout.trim().split("\n")[0] || null;
-}
-/**
- * Run multiple commands concurrently with limited concurrency.
- *
- * This is the key function for preventing resource contention.
- * Uses async spawn with concurrency limiting built-in.
- */
-export async function safeSpawnBatch(commands, concurrency = 3) {
-    const results = [];
-    // Process in batches to limit concurrent processes
-    for (let i = 0; i < commands.length; i += concurrency) {
-        const batch = commands.slice(i, i + concurrency);
-        const batchResults = await Promise.all(batch.map(({ command, args, options }) => safeSpawnAsync(command, args, options)));
-        results.push(...batchResults);
-    }
-    return results;
-}

package/clients/safe-spawn.js

@@ -1,241 +0,0 @@
-/**
- * Safe cross-platform spawn utilities
- *
- * Provides both sync (deprecated) and async versions for gradual migration.
- *
- * Async version features:
- * - Non-blocking execution
- * - Proper process cleanup on timeout (no zombies)
- * - Batch execution with concurrency limits
- * - AbortSignal support for cancellation
- *
- * Migration guide:
- * - Change: safeSpawn(cmd, args, opts)
- * - To: await safeSpawnAsync(cmd, args, opts)
- */
-import { spawn, spawnSync } from "node:child_process";
-// ============================================================================
-// ASYNC VERSION (Recommended - Non-blocking)
-// ============================================================================
-/**
- * Async spawn with timeout and proper process cleanup.
- *
- * Unlike spawnSync, this:
- * - Doesn't block the event loop
- * - Kills the process on timeout (preventing zombies)
- * - Supports cancellation via AbortSignal
- *
- * @example
- * const result = await safeSpawnAsync("npm", ["test"], { timeout: 30000 });
- * if (result.error) console.error("Failed:", result.error);
- */
-export async function safeSpawnAsync(command, args, options) {
-    const timeout = options?.timeout ?? 30000;
-    const abortSignal = options?.signal;
-    return new Promise((resolve) => {
-        // Check for early abort
-        if (abortSignal?.aborted) {
-            resolve({
-                stdout: "",
-                stderr: "",
-                status: null,
-                error: new Error("Spawn aborted before start"),
-            });
-            return;
-        }
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        let killed = false;
-        // Spawn the process (non-blocking)
-        // On Windows, use shell mode for .cmd files (like pyright, biome)
-        const isWindows = process.platform === "win32";
-        const child = spawn(command, args, {
-            cwd: options?.cwd,
-            env: { ...process.env, ...options?.env },
-            windowsHide: true,
-            shell: isWindows,
-        });
-        // Handle abort signal
-        const onAbort = () => {
-            if (!killed && !child.killed) {
-                killed = true;
-                child.kill("SIGTERM");
-                // Force kill after 1s if still running
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill("SIGKILL");
-                    }
-                }, 1000);
-            }
-        };
-        abortSignal?.addEventListener("abort", onAbort, { once: true });
-        // Collect output
-        child.stdout?.setEncoding("utf-8");
-        child.stderr?.setEncoding("utf-8");
-        child.stdout?.on("data", (data) => (stdout += data));
-        child.stderr?.on("data", (data) => (stderr += data));
-        // Timeout handling - KILL the process, don't just abandon it
-        const timeoutId = setTimeout(() => {
-            timedOut = true;
-            if (!killed && !child.killed) {
-                killed = true;
-                child.kill("SIGTERM");
-                // Force kill after 1s grace period
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill("SIGKILL");
-                    }
-                }, 1000);
-            }
-        }, timeout);
-        // Process completion
-        child.on("close", (code, signal) => {
-            clearTimeout(timeoutId);
-            abortSignal?.removeEventListener("abort", onAbort);
-            if (timedOut) {
-                resolve({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: new Error(`Process timed out after ${timeout}ms (killed with ${signal || "SIGTERM"})`),
-                });
-            }
-            else if (signal) {
-                resolve({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: new Error(`Process killed by signal: ${signal}`),
-                });
-            }
-            else {
-                resolve({ stdout, stderr, status: code });
-            }
-        });
-        child.on("error", (err) => {
-            clearTimeout(timeoutId);
-            abortSignal?.removeEventListener("abort", onAbort);
-            resolve({ stdout, stderr, status: null, error: err });
-        });
-    });
-}
-/**
- * Run multiple commands concurrently with limited concurrency.
- *
- * This prevents resource contention when running many linters.
- * Uses async spawn with concurrency limiting built-in.
- *
- * @example
- * const results = await safeSpawnBatch([
- *   { command: "biome", args: ["check", "file.ts"] },
- *   { command: "ruff", args: ["check", "file.py"] },
- * ], 3); // Max 3 concurrent
- */
-export async function safeSpawnBatch(commands, concurrency = 3) {
-    const results = [];
-    // Process in batches to limit concurrent processes
-    for (let i = 0; i < commands.length; i += concurrency) {
-        const batch = commands.slice(i, i + concurrency);
-        const batchResults = await Promise.all(batch.map(({ command, args, options }) => safeSpawnAsync(command, args, options)));
-        results.push(...batchResults);
-    }
-    return results;
-}
-/**
- * Check if a command is available in PATH (async version)
- */
-export async function isCommandAvailableAsync(command) {
-    const finder = process.platform === "win32" ? "where" : "which";
-    const result = await safeSpawnAsync(finder, [command], { timeout: 5000 });
-    return result.status === 0 && !result.error;
-}
-/**
- * Find the full path to a command (async version)
- */
-export async function findCommandAsync(command) {
-    const finder = process.platform === "win32" ? "where" : "which";
-    const result = await safeSpawnAsync(finder, [command], { timeout: 5000 });
-    if (result.status !== 0 || result.error)
-        return null;
-    // Take first line (first match)
-    return result.stdout.trim().split("\n")[0] || null;
-}
-// ============================================================================
-// SYNC VERSION (Deprecated - Blocking, for backward compatibility)
-// ============================================================================
-/**
- * Escape an argument for Windows shell execution.
- * Handles spaces, quotes, $variables, and special characters.
- */
-function escapeWindowsArg(arg) {
-    if (arg.includes("$")) {
-        return `'${arg.replace(/'/g, "'\\''")}'`;
-    }
-    if (!/[\s"]/.test(arg))
-        return arg;
-    return `"${arg.replace(/"/g, '""')}"`;
-}
-/**
- * Construct a command string for Windows shell execution.
- */
-function buildWindowsCommand(command, args) {
-    const escapedArgs = args.map(escapeWindowsArg).join(" ");
-    return `${command} ${escapedArgs}`;
-}
-/**
- * ⚠️ DEPRECATED: Use safeSpawnAsync instead.
- *
- * This blocks the entire Node.js event loop until the process exits.
- * If the process hangs, pi will freeze.
- *
- * Kept for backward compatibility during migration.
- */
-export function safeSpawn(command, args, options) {
-    if (process.platform === "win32") {
-        const fullCommand = buildWindowsCommand(command, args);
-        const result = spawnSync(fullCommand, {
-            ...options,
-            encoding: "utf-8",
-            shell: true,
-            windowsHide: true,
-        });
-        return {
-            stdout: result.stdout?.toString() || "",
-            stderr: result.stderr?.toString() || "",
-            status: result.status,
-            error: result.error,
-        };
-    }
-    const result = spawnSync(command, args, {
-        ...options,
-        encoding: "utf-8",
-        shell: false,
-        windowsHide: true,
-    });
-    return {
-        stdout: result.stdout?.toString() || "",
-        stderr: result.stderr?.toString() || "",
-        status: result.status,
-        error: result.error,
-    };
-}
-/**
- * Check if a command is available in PATH (sync version - deprecated)
- * @deprecated Use isCommandAvailableAsync
- */
-export function isCommandAvailable(command) {
-    const result = safeSpawn(process.platform === "win32" ? "where" : "which", [command], { timeout: 5000 });
-    return result.status === 0;
-}
-/**
- * Find the full path to a command (sync version - deprecated)
- * @deprecated Use findCommandAsync
- */
-export function findCommand(command) {
-    const finder = process.platform === "win32" ? "where" : "which";
-    const result = safeSpawn(finder, [command], { timeout: 5000 });
-    if (result.status !== 0)
-        return null;
-    return result.stdout.trim().split("\n")[0] || null;
-}

package/clients/sanitize.js

@@ -1,291 +0,0 @@
-/**
- * Tool Output Sanitization for pi-lens
- *
- * Cleans and normalizes tool output for display to users.
- * Removes ANSI codes, extracts key error messages, etc.
- */
-// --- Constants ---
-// ANSI escape codes for colors and formatting
-const ANSI_ESCAPE = /\x1b\[[0-9;]*m/g;
-const ANSI_ESCAPE_EXTENDED = /\x1b\[[0-9;]*[A-Za-z]/g;
-// Common error patterns from different tools
-const ERROR_INDICATORS = [
-    /\berror\b/i,
-    /\bfailed\b/i,
-    /\bfatal\b/i,
-    /\binvalid\b/i,
-    /\bunexpected\b/i,
-    /\bexpected\b/i,
-    /\bsyntax\b/i,
-    /\bcannot find\b/i,
-    /\bnot found\b/i,
-    /\bno such\b/i,
-];
-// Patterns that indicate a line is a "detail" rather than an error
-const DETAIL_PATTERNS = [
-    /^help wanted/i,
-    /^note:/i,
-    /^hint:/i,
-    /^→/,
-    /^\s*at\s+/, // Stack traces
-    /^ {4}/, // Indented continuation
-];
-// --- Core Sanitization Functions ---
-/**
- * Remove ANSI escape sequences from a string.
- */
-export function stripAnsi(text) {
-    return text.replace(ANSI_ESCAPE, "").replace(ANSI_ESCAPE_EXTENDED, "");
-}
-/**
- * Normalize whitespace in a string.
- * Collapses multiple spaces/tabs to single space, trims lines.
- */
-export function normalizeWhitespace(text) {
-    return text
-        .split(/\r?\n/)
-        .map((line) => line.replace(/\s+/g, " ").trim())
-        .filter((line) => line.length > 0)
-        .join("\n");
-}
-/**
- * Check if a line contains error indicators.
- */
-function isErrorLine(line) {
-    const cleanLine = stripAnsi(line).trim();
-    return ERROR_INDICATORS.some((pattern) => pattern.test(cleanLine));
-}
-/**
- * Check if a line is a "detail" line (continuation, stack trace, etc.)
- * that shouldn't be shown as a standalone error.
- */
-function isDetailLine(line) {
-    const cleanLine = stripAnsi(line).trim();
-    return DETAIL_PATTERNS.some((pattern) => pattern.test(cleanLine));
-}
-/**
- * Sanitize a single line of tool output.
- * Removes ANSI codes and normalizes common patterns.
- */
-export function sanitizeLine(line) {
-    return stripAnsi(line)
-        .replace(/^\s*\[error\]\s*/i, "")
-        .replace(/^\s*error:\s*/i, "")
-        .replace(/^\s*[×✖✘✗]\s*/u, "")
-        .replace(/^\s*[✓✔]\s*/u, "")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-/**
- * Sanitize multi-line tool output.
- * Returns cleaned lines, filtered to relevant content.
- */
-export function sanitizeOutput(output) {
-    if (!output || typeof output !== "string") {
-        return "";
-    }
-    const lines = output.split(/\r?\n/);
-    const sanitized = lines
-        .map((line) => sanitizeLine(line))
-        .filter((line) => line.length > 0)
-        .filter((line) => !isDetailLine(line));
-    return sanitized.join("\n");
-}
-/**
- * Extract the most relevant error message from tool output.
- * Returns the first line that contains error indicators, or the first non-empty line.
- */
-export function extractErrorMessage(output) {
-    if (!output || typeof output !== "string") {
-        return undefined;
-    }
-    const lines = output
-        .split(/\r?\n/)
-        .map((line) => sanitizeLine(line))
-        .filter((line) => line.length > 0);
-    if (lines.length === 0) {
-        return undefined;
-    }
-    // Find first line with error indicators
-    const errorLine = lines.find((line) => isErrorLine(line));
-    if (errorLine) {
-        return errorLine;
-    }
-    // Fall back to first non-detail line
-    const firstMain = lines.find((line) => !isDetailLine(line));
-    return firstMain;
-}
-/**
- * Truncate a message to a maximum length, adding ellipsis if needed.
- */
-export function truncateMessage(message, maxLength = 140) {
-    if (message.length <= maxLength) {
-        return message;
-    }
-    return `${message.slice(0, maxLength - 1)}…`;
-}
-// --- Tool-Specific Sanitizers ---
-/**
- * Sanitize TypeScript/LSP diagnostic output.
- */
-export function sanitizeTsDiagnostic(output) {
-    if (!output)
-        return "";
-    // TypeScript errors often look like:
-    // error TS2322: Type 'string' is not assignable to type 'number'.
-    // or:
-    // src/file.ts(10,5): error TS2322: ...
-    const lines = output
-        .split(/\r?\n/)
-        .map((line) => stripAnsi(line))
-        .filter((line) => line.length > 0)
-        // Filter out non-error lines
-        .filter((line) => line.includes("error TS") || line.includes("warning TS"));
-    // If we have file:line:col format errors, extract those
-    const fileErrors = lines
-        .filter((line) => /^.+?\([\d,]+\):/.test(line))
-        .map((line) => {
-        // Extract file:line:col from the beginning
-        const match = line.match(/^(.+?\([\d,]+\):)\s*(.+)/);
-        if (match) {
-            return `${match[1]} ${match[2].trim()}`;
-        }
-        return line.trim();
-    });
-    if (fileErrors.length > 0) {
-        return fileErrors.slice(0, 10).join("\n");
-    }
-    // Otherwise just return error lines
-    return lines.slice(0, 5).join("\n");
-}
-// --- Helper Functions ---
-/**
- * Extract error/warning lines from tool output.
- * Filters and formats lines containing diagnostic information.
- */
-function extractDiagnosticLines(output, predicate, maxLines = 10) {
-    if (!output)
-        return "";
-    return output
-        .split(/\r?\n/)
-        .map((line) => stripAnsi(line))
-        .filter((line) => line.length > 0)
-        .filter(predicate)
-        .slice(0, maxLines)
-        .join("\n");
-}
-/**
- * Format JSON diagnostics array into readable output.
- */
-function formatJsonDiagnostics(diags, formatter) {
-    return diags.slice(0, 10).map(formatter).join("\n");
-}
-// --- Tool-Specific Sanitizers ---
-/**
- * Sanitize Rust cargo output.
- */
-export function sanitizeRustOutput(output) {
-    if (!output)
-        return "";
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return (isErrorLine(clean) || /^\s*-->\s+/.test(clean) // rustc source locations
-        );
-    });
-}
-/**
- * Sanitize Go vet output.
- */
-export function sanitizeGoOutput(output) {
-    if (!output)
-        return "";
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return /^\.\/|\.go:/.test(clean) || isErrorLine(clean);
-    });
-}
-/**
- * Sanitize Biome output.
- */
-export function sanitizeBiomeOutput(output) {
-    if (!output)
-        return "";
-    try {
-        const data = JSON.parse(output);
-        if (data.diagnostics && Array.isArray(data.diagnostics)) {
-            return formatJsonDiagnostics(data.diagnostics, (d) => {
-                const loc = d.location;
-                const file = loc?.path ? `${loc.path}` : "";
-                const line = loc?.span?.start?.line ?? 0;
-                const msg = d.message || "";
-                return file ? `${file}:${line + 1} ${msg}` : msg;
-            });
-        }
-    }
-    catch (err) {
-        void err;
-        // Not JSON, fall through to text processing
-    }
-    // Text output processing
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return isErrorLine(clean) || clean.includes("hint");
-    });
-}
-/**
- * Sanitize Ruff output.
- */
-export function sanitizeRuffOutput(output) {
-    if (!output)
-        return "";
-    try {
-        const data = JSON.parse(output);
-        if (Array.isArray(data)) {
-            return formatJsonDiagnostics(data, (d) => {
-                const row = d.location?.row ?? 0;
-                const col = d.location?.column ?? 0;
-                const code = d.code || "";
-                const msg = d.message || "";
-                return `${row}:${col} [${code}] ${msg}`;
-            });
-        }
-    }
-    catch (err) {
-        void err;
-        // Not JSON, fall through
-    }
-    // Text output
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return isErrorLine(clean) || /\[(E|W)\d+\]/.test(clean);
-    });
-}
-/**
- * Sanitize tool output and return both a summary and full details.
- * Summary is the first error line, details is the full cleaned output.
- */
-export function sanitizeToolOutput(output, maxSummaryLength = 140) {
-    if (!output || typeof output !== "string") {
-        return { summary: undefined, details: undefined, truncated: false };
-    }
-    const sanitized = sanitizeOutput(output);
-    const lines = sanitized.split("\n").filter((l) => l.length > 0);
-    if (lines.length === 0) {
-        return { summary: undefined, details: undefined, truncated: false };
-    }
-    // Summary: first line with error indicators, or first line
-    const summary = extractErrorMessage(output);
-    const truncatedSummary = truncateMessage(summary ?? lines[0], maxSummaryLength);
-    // Details: all lines up to a reasonable limit
-    const MAX_DETAIL_LINES = 20;
-    const detailsLines = lines.slice(0, MAX_DETAIL_LINES);
-    const details = detailsLines.join("\n");
-    const truncated = lines.length > MAX_DETAIL_LINES;
-    return {
-        summary: truncatedSummary,
-        details: truncated
-            ? `${details}\n... and ${lines.length - MAX_DETAIL_LINES} more lines`
-            : details,
-        truncated,
-    };
-}