@runloop/rl-cli 0.4.0 → 0.9.0

package/dist/utils/memoryMonitor.js

@@ -1,85 +0,0 @@
-/**
- * Memory Monitor - Track memory usage and manage GC
- * Helps prevent heap exhaustion during navigation
- */
-let lastMemoryUsage = null;
-let gcAttempts = 0;
-const MAX_GC_ATTEMPTS_PER_MINUTE = 5;
-let lastGCReset = Date.now();
-// Memory thresholds (in bytes)
-const HEAP_WARNING_THRESHOLD = 3.5e9; // 3.5 GB
-const HEAP_CRITICAL_THRESHOLD = 4e9; // 4 GB
-export function logMemoryUsage(label) {
-    if (process.env.NODE_ENV === "development" || process.env.DEBUG_MEMORY) {
-        const current = process.memoryUsage();
-        const heapUsedMB = (current.heapUsed / 1024 / 1024).toFixed(2);
-        const heapTotalMB = (current.heapTotal / 1024 / 1024).toFixed(2);
-        const rssMB = (current.rss / 1024 / 1024).toFixed(2);
-        let delta = "";
-        if (lastMemoryUsage) {
-            const heapDelta = current.heapUsed - lastMemoryUsage.heapUsed;
-            const heapDeltaMB = (heapDelta / 1024 / 1024).toFixed(2);
-            delta = ` (Δ ${heapDeltaMB}MB)`;
-        }
-        console.error(`[MEMORY] ${label}: Heap ${heapUsedMB}/${heapTotalMB}MB, RSS ${rssMB}MB${delta}`);
-        // Warn if approaching limits
-        if (current.heapUsed > HEAP_WARNING_THRESHOLD) {
-            console.warn(`[MEMORY WARNING] Heap usage is high: ${heapUsedMB}MB (threshold: 3500MB)`);
-        }
-        lastMemoryUsage = current;
-    }
-}
-export function getMemoryPressure() {
-    const usage = process.memoryUsage();
-    const heapUsedPercent = (usage.heapUsed / usage.heapTotal) * 100;
-    if (usage.heapUsed > HEAP_CRITICAL_THRESHOLD || heapUsedPercent > 95)
-        return "critical";
-    if (usage.heapUsed > HEAP_WARNING_THRESHOLD || heapUsedPercent > 85)
-        return "high";
-    if (heapUsedPercent > 70)
-        return "medium";
-    return "low";
-}
-export function shouldTriggerGC() {
-    const pressure = getMemoryPressure();
-    return pressure === "high" || pressure === "critical";
-}
-/**
- * Force garbage collection if available and needed
- * Respects rate limiting to avoid GC thrashing
- */
-export function tryForceGC(reason) {
-    // Reset GC attempt counter every minute
-    const now = Date.now();
-    if (now - lastGCReset > 60000) {
-        gcAttempts = 0;
-        lastGCReset = now;
-    }
-    // Rate limit GC attempts
-    if (gcAttempts >= MAX_GC_ATTEMPTS_PER_MINUTE) {
-        return false;
-    }
-    // Check if global.gc is available (requires --expose-gc flag)
-    if (typeof global.gc === "function") {
-        const beforeHeap = process.memoryUsage().heapUsed;
-        global.gc();
-        gcAttempts++;
-        const afterHeap = process.memoryUsage().heapUsed;
-        const freedMB = ((beforeHeap - afterHeap) / 1024 / 1024).toFixed(2);
-        if (process.env.DEBUG_MEMORY) {
-            console.error(`[MEMORY] Forced GC${reason ? ` (${reason})` : ""}: Freed ${freedMB}MB`);
-        }
-        return true;
-    }
-    return false;
-}
-/**
- * Monitor memory and trigger GC if needed
- * Call this after major operations like screen transitions
- */
-export function checkMemoryPressure() {
-    const pressure = getMemoryPressure();
-    if (pressure === "critical" || pressure === "high") {
-        tryForceGC(`Memory pressure: ${pressure}`);
-    }
-}

package/dist/utils/process.js

@@ -1,106 +0,0 @@
-/**
- * Process utilities wrapper for testability.
- *
- * This module provides wrappers around Node.js process functions
- * that can be easily mocked in tests.
- */
-/**
- * Default implementation using real process
- */
-const defaultProcess = {
-    exit: (code) => {
-        process.exit(code);
-    },
-    stdout: {
-        write: (data) => process.stdout.write(data),
-        get isTTY() {
-            return process.stdout.isTTY;
-        },
-    },
-    stderr: {
-        write: (data) => process.stderr.write(data),
-    },
-    get env() {
-        return process.env;
-    },
-    cwd: () => process.cwd(),
-};
-/**
- * Current process implementation - can be swapped for testing
- */
-let currentProcess = defaultProcess;
-/**
- * Get the current process wrapper
- */
-export function getProcess() {
-    return currentProcess;
-}
-/**
- * Set a custom process wrapper (for testing)
- */
-export function setProcess(proc) {
-    currentProcess = proc;
-}
-/**
- * Reset to the default process wrapper
- */
-export function resetProcess() {
-    currentProcess = defaultProcess;
-}
-/**
- * Exit the process with an optional exit code
- */
-export function exitProcess(code) {
-    return currentProcess.exit(code);
-}
-/**
- * Write to stdout
- */
-export function writeStdout(data) {
-    return currentProcess.stdout.write(data);
-}
-/**
- * Write to stderr
- */
-export function writeStderr(data) {
-    return currentProcess.stderr.write(data);
-}
-/**
- * Check if stdout is a TTY
- */
-export function isStdoutTTY() {
-    return !!currentProcess.stdout.isTTY;
-}
-/**
- * Get environment variable
- */
-export function getEnv(key) {
-    return currentProcess.env[key];
-}
-/**
- * Get current working directory
- */
-export function getCwd() {
-    return currentProcess.cwd();
-}
-/**
- * Create a mock process for testing
- */
-export function createMockProcess(overrides = {}) {
-    const exitFn = jest.fn();
-    const stdoutWriteFn = jest.fn().mockReturnValue(true);
-    const stderrWriteFn = jest.fn().mockReturnValue(true);
-    const cwdFn = jest.fn().mockReturnValue("/mock/cwd");
-    return {
-        exit: overrides.exit ?? exitFn,
-        stdout: overrides.stdout ?? {
-            write: stdoutWriteFn,
-            isTTY: true,
-        },
-        stderr: overrides.stderr ?? {
-            write: stderrWriteFn,
-        },
-        env: overrides.env ?? {},
-        cwd: overrides.cwd ?? cwdFn,
-    };
-}

package/dist/utils/versionCheck.js

@@ -1,53 +0,0 @@
-import { shouldCheckForUpdates, updateCheckCache } from "./config.js";
-import { VERSION } from "../cli.js";
-/**
- * Check if a new version is available on npm
- * Uses caching to avoid checking too frequently
- */
-export async function checkForUpdates() {
-    const currentVersion = VERSION;
-    // Check if we should check for updates (respects cache)
-    if (!shouldCheckForUpdates()) {
-        return {
-            isUpdateAvailable: false,
-            latestVersion: null,
-            currentVersion,
-        };
-    }
-    try {
-        // Fetch latest version from npm registry
-        const response = await fetch("https://registry.npmjs.org/@runloop/rl-cli/latest", {
-            headers: {
-                Accept: "application/json",
-            },
-        });
-        if (!response.ok) {
-            // If fetch fails, don't show update message
-            return {
-                isUpdateAvailable: false,
-                latestVersion: null,
-                currentVersion,
-            };
-        }
-        const data = (await response.json());
-        const latestVersion = data.version;
-        // Update the cache
-        updateCheckCache();
-        // Compare versions (simple string comparison works for semver)
-        const isUpdateAvailable = latestVersion !== currentVersion;
-        return {
-            isUpdateAvailable,
-            latestVersion,
-            currentVersion,
-        };
-    }
-    catch (error) {
-        // Silently fail - don't show update message if check fails
-        // This prevents network errors from disrupting the user experience
-        return {
-            isUpdateAvailable: false,
-            latestVersion: null,
-            currentVersion,
-        };
-    }
-}