pipm 1.0.0

package/README.md

@@ -0,0 +1,54 @@
+# pipm
+
+Stop staring at that awkward, infinite loading spinner. **pipm** is a Python-inspired wrapper for **npm** that actually tells you what's happening behind the scenes.
+
+## The "Is it stuck?" Problem
+
+We've all been there: you run `npm install`, the spinner starts spinning, and then... nothing. For 5 minutes. You start wondering if your internet died, if your terminal crashed, or if `npm` is just having a mid-life crisis.
+
+**pipm** turns that "silent wait" into a bit of literal fun. Instead of a vague spinner, you get a full dashboard showing you exactly what's moving under the hood.
+
+## Cool Stuff it Does
+
+*   **Real Speed Monitoring:** No fake "estimated" percentages. It polls your system's network adapter directly to show you exactly how many MB/s your machine is pulling.
+*   **PIP-Style Progress Bar:** High-contrast Green (done) and Red (to-go) bar.
+*   **State-Aware Humor:** Keeps you engaged with 50+ status phrases. You'll get startup, working, and finishing jokes based on the actual stage of the install.
+*   **Zero Bloat:** Built with 100% native Node.js. No extra `node_modules` to download to make the tool work.
+*   **Flicker-Free:** Custom rendering that overwrites lines instead of clearing the screen, so it doesn't blink like an old neon sign.
+
+## Installation
+
+Just install it globally and you're good to go:
+
+```bash
+npm install -g .
+```
+
+## How to use it
+
+Use it exactly like you use `npm`. There's nothing new to learn. 
+
+```bash
+# Standard install
+pipm install
+
+# Adding stuff
+pipm add lodash express shadcn
+
+# Anything else
+pipm init
+pipm run dev
+```
+
+## How it works (The technical bit)
+
+`pipm` is a wrapper, not a replacement. When you run a command, it:
+1.  Spawns the official `npm` process in the background.
+2.  Forces npm into `http` log mode so we can "see" every download request.
+3.  Calculates your network bandwidth by tracking your OS's `ReceivedBytes` (it works on Windows, Mac, and Linux).
+4.  Uses ANSI escape codes to redraw the UI in-place every few hundred milliseconds.
+
+Basically, it's a personality-filled skin for the npm engine we already know and love.
+
+---
+Enjoy the status fun to keep you engaged while you wait! :)

package/bin/pipm.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+const { spawn, execSync } = require('child_process');
+const readline = require('readline');
+
+const ESC = '\x1b';
+const HIDE_CURSOR = `${ESC}[?25l`;
+const SHOW_CURSOR = `${ESC}[?25h`;
+
+const c = {
+    reset: `${ESC}[0m`,
+    cyan: `${ESC}[36m`,
+    gray: `${ESC}[90m`,
+    white: `${ESC}[97m`,
+    green: `${ESC}[32m`,
+    red: `${ESC}[31m`,
+    yellow: `${ESC}[33m`
+};
+
+const phrases = {
+    startup: [
+        'Waking up the npm hamsters...',
+        'Shoveling coal into the server pipes...',
+        'Bribing the registry servers...',
+        'Warming up the download engines...',
+        'Assembling the code avengers...',
+        'Consulting the package oracle...',
+        'Summoning dependencies from the void...',
+        'Performing npm rain dance...',
+        'Priming the dependency pump...',
+        'Calibrating the package-o-meter...',
+        'Greasing the internet tubes...',
+        'Checking if the internet is plugged in...',
+        'Initializing the hyperdrive...',
+        'Knocking on the registry door...'
+    ],
+    working: [
+        'Negotiating with the node_modules black hole...',
+        'Teaching the code how to behave...',
+        'Convincing packages to cooperate...',
+        'Downloading the internet (just the good parts)...',
+        'Herding digital cats...',
+        'Brewing some fresh dependencies...',
+        'Asking packages nicely to install...',
+        'Untangling the dependency spaghetti...',
+        'Waiting for the bits to align...',
+        'Compiling prayers to the JavaScript gods...',
+        'Reticulating splines...',
+        'Convincing electrons to flow faster...',
+        'Parsing the meaning of life...',
+        'Optimizing the speed of light...',
+        'Untangling quantum dependencies...',
+        'Feeding the code monkeys...',
+        'Polishing the bits and bytes...',
+        'Synchronizing with the cloud hamsters...',
+        'Wrangling 1s and 0s...',
+        'Balancing the load on the hamsters...',
+        'Dodging 404s...',
+        'Refactoring the universe...',
+        'Applying digital WD-40...',
+        'Compressing the space-time continuum...',
+        'Organizing the bits by color...',
+        'Spinning up the logic turbines...',
+        'Hunting for the missing semicolons...',
+        'Buffering the excitement...',
+        'Distilling the pure essence of JS...',
+        'Searching for the holy grail of dependencies...',
+        'Whispering sweet nothings to the terminal...',
+        'Trying to find where I put that variable...'
+    ],
+    finishing: [
+        'Tidying up the node_modules room...',
+        'Double-checking the semicolon count...',
+        'Making sure the code is happy...',
+        'Finalizing the digital handshake...',
+        'Cleaning up the virtual workspace...',
+        'Telling the hamsters they did a good job...',
+        'Inspecting the dependency tree for splinters...',
+        'Removing the training wheels...',
+        'Signing the digital peace treaty...',
+        'Polishing the final bundle...',
+        'Putting the bits to bed...',
+        'Wrapping it all up in a digital bow...'
+    ]
+};
+
+function getStatusPhrase(completedCount, isFinished = false) {
+    let category = 'working';
+    if (isFinished) {
+        category = 'finishing';
+    } else if (completedCount === 0) {
+        category = 'startup';
+    }
+
+    const list = phrases[category];
+    return list[Math.floor(Math.random() * list.length)];
+}
+
+function formatTime(seconds) {
+    const hrs = Math.floor(seconds / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${hrs.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+}
+
+function formatSpeed(bytesPerSec) {
+    if (bytesPerSec >= 1024 * 1024) {
+        return (bytesPerSec / (1024 * 1024)).toFixed(1) + ' MB/s';
+    } else if (bytesPerSec >= 1024) {
+        return (bytesPerSec / 1024).toFixed(1) + ' KB/s';
+    }
+    return bytesPerSec.toFixed(0) + ' B/s';
+}
+
+function extractPackageName(url) {
+    try {
+        const urlObj = new URL(url);
+        const pathname = urlObj.pathname;
+
+        if (pathname.includes('/-/')) {
+            const parts = pathname.split('/-/');
+            if (parts.length >= 2) return parts[1];
+        }
+
+        if (pathname.startsWith('/@')) {
+            const parts = pathname.split('/');
+            if (parts.length >= 3) return `${parts[1]}/${parts[2]}`;
+        }
+
+        const parts = pathname.split('/');
+        return parts.length >= 2 ? parts[1] : pathname;
+    } catch {
+        return url.substring(0, 50);
+    }
+}
+
+function getNetworkBytes() {
+    try {
+        if (process.platform === 'win32') {
+            const output = execSync('netstat -e', { stdio: ['pipe', 'pipe', 'ignore'], timeout: 500 }).toString();
+            const match = output.match(/Bytes\s+(\d+)/i);
+            return match ? parseInt(match[1]) : 0;
+        } else if (process.platform === 'darwin') {
+            const output = execSync('netstat -ibn', { stdio: ['pipe', 'pipe', 'ignore'], timeout: 500 }).toString();
+            const lines = output.split('\n');
+            let totalBytes = 0;
+            for (let i = 1; i < lines.length; i++) {
+                const parts = lines[i].trim().split(/\s+/);
+                if (parts.length >= 7) {
+                    const val = parseInt(parts[6]);
+                    if (!isNaN(val)) totalBytes += val;
+                }
+            }
+            return totalBytes;
+        } else {
+            const fs = require('fs');
+            if (fs.existsSync('/proc/net/dev')) {
+                const data = fs.readFileSync('/proc/net/dev', 'utf8');
+                const lines = data.split('\n');
+                let totalBytes = 0;
+                for (let i = 2; i < lines.length; i++) {
+                    const parts = lines[i].trim().split(/\s+/);
+                    if (parts.length > 1) {
+                        totalBytes += parseInt(parts[1]) || 0;
+                    }
+                }
+                return totalBytes;
+            }
+            return 0;
+        }
+    } catch (e) {
+        return 0;
+    }
+}
+
+function buildProgressBar(percent, width = 40) {
+    const p = Math.max(0, Math.min(100, percent));
+    const filledCount = Math.floor((p / 100) * width);
+    const remainingCount = width - filledCount;
+
+    const filledPart = `${c.green}${'\u2501'.repeat(filledCount)}${c.reset}`;
+    const emptyPart = `${c.red}${'\u2501'.repeat(remainingCount)}${c.reset}`;
+
+    return filledPart + emptyPart;
+}
+
+function pad(str, length) {
+    const s = String(str);
+    const visibleLength = s.replace(/\x1b\[[0-9;]*m/g, '').length;
+    if (visibleLength >= length) return s;
+    return s + ' '.repeat(length - visibleLength);
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        const npm = spawn('npm', args, { stdio: 'inherit', shell: true });
+        npm.on('close', (code) => process.exit(code));
+        return;
+    }
+
+    const isInstall = ['install', 'i', 'add', 'ci'].includes(args[0]);
+    if (!isInstall) {
+        const npm = spawn('npm', args, { stdio: 'inherit', shell: true });
+        npm.on('close', (code) => process.exit(code));
+        return;
+    }
+
+    const displayCommand = 'npm ' + args.join(' ');
+
+    let completedRequests = 0;
+    let startTime = Date.now();
+    let phraseChangeTime = Date.now();
+    let currentStatus = getStatusPhrase(0);
+    let currentAction = 'Initializing...';
+
+    let displayProgress = 0;
+    let targetProgress = 0;
+    let isDownloading = false;
+
+    let lastNetworkBytes = getNetworkBytes();
+    let currentSpeed = 0;
+
+    const LINE_COUNT = 5;
+    const TERMINAL_WIDTH = process.stdout.columns || 80;
+
+    process.stdout.write(HIDE_CURSOR);
+
+    console.log('');
+    console.log(`${c.cyan}pipm${c.reset}${c.gray} |${c.reset}  Running: ${c.gray}${displayCommand}${c.reset}`);
+    console.log('');
+
+    const npmArgs = [...args, '--loglevel', 'http'];
+    const npm = spawn('npm', npmArgs, {
+        shell: true,
+        stdio: ['inherit', 'pipe', 'pipe']
+    });
+
+    function render(complete = false) {
+        const totalElapsed = formatTime((Date.now() - startTime) / 1000);
+        const pkgText = completedRequests === 1 ? 'package' : 'packages';
+
+        const finalProgress = complete ? 100 : Math.floor(displayProgress);
+        const bar = buildProgressBar(finalProgress);
+        const icon = complete ? `${c.green}✓${c.reset}` : (isDownloading ? `${c.cyan}↓${c.reset}` : '·');
+        const speedText = (!complete && currentSpeed > 0) ? ` ${c.yellow}${formatSpeed(currentSpeed)}${c.reset}` : '';
+
+        readline.moveCursor(process.stdout, 0, -LINE_COUNT);
+
+        const line1 = `${c.cyan}pipm${c.reset} ${bar} ${icon} ${completedRequests} ${pkgText}${speedText}`;
+        process.stdout.write(pad(line1, TERMINAL_WIDTH) + '\n');
+        process.stdout.write(pad('', TERMINAL_WIDTH) + '\n');
+
+        const line3 = `${c.gray}Total Time:${c.reset} ${totalElapsed}`;
+        process.stdout.write(pad(line3, TERMINAL_WIDTH) + '\n');
+
+        const line4 = `${c.gray}Status:${c.reset} ${currentStatus}`;
+        process.stdout.write(pad(line4, TERMINAL_WIDTH) + '\n');
+
+        const line5 = `${c.gray}Action:${c.reset} ${currentAction}`;
+        process.stdout.write(pad(line5, TERMINAL_WIDTH) + '\n');
+    }
+
+    console.log(`${c.cyan}pipm${c.reset} ${buildProgressBar(0)} · 0 packages`);
+    console.log('');
+    console.log(`${c.gray}Total Time:${c.reset} 00:00:00`);
+    console.log(`${c.gray}Status:${c.reset} ${currentStatus}`);
+    console.log(`${c.gray}Action:${c.reset} Initializing...`);
+
+    const updateInterval = setInterval(() => {
+        if (Date.now() - phraseChangeTime > 5000) {
+            currentStatus = getStatusPhrase(completedRequests);
+            phraseChangeTime = Date.now();
+        }
+
+        const nowBytes = getNetworkBytes();
+        if (nowBytes > lastNetworkBytes) {
+            currentSpeed = (nowBytes - lastNetworkBytes) / 0.2;
+        } else {
+            currentSpeed = 0;
+        }
+        lastNetworkBytes = nowBytes;
+
+        if (displayProgress < targetProgress) {
+            const step = Math.max(2, (targetProgress - displayProgress) * 0.1);
+            displayProgress = Math.min(targetProgress, displayProgress + step);
+        } else if (isDownloading && targetProgress < 95) {
+            targetProgress += 0.5;
+        }
+
+        render();
+    }, 200);
+
+    npm.stdout.on('data', () => { });
+
+    npm.stderr.on('data', (data) => {
+        const lines = data.toString().split('\n');
+        for (const line of lines) {
+            const startMatch = line.match(/npm http fetch GET (https?:\/\/[^\s]+)/i);
+            if (startMatch && !line.match(/\s\d{3}\s/)) {
+                isDownloading = true;
+                displayProgress = 0;
+                targetProgress = 40;
+                currentAction = `Fetching ${extractPackageName(startMatch[1])}`;
+            }
+
+            const completeMatch = line.match(/npm http fetch (GET|POST) (\d+) (https?:\/\/[^\s]+)/i);
+            if (completeMatch) {
+                completedRequests++;
+                targetProgress = 100;
+                displayProgress = 100;
+                currentAction = `Fetched ${extractPackageName(completeMatch[3])}`;
+
+                setTimeout(() => {
+                    displayProgress = 0;
+                    targetProgress = 0;
+                    isDownloading = false;
+                }, 200);
+            }
+
+            if (isDownloading && targetProgress < 90) {
+                targetProgress = Math.min(90, targetProgress + 15);
+            }
+        }
+    });
+
+    npm.on('close', (code) => {
+        clearInterval(updateInterval);
+        const elapsed = (Date.now() - startTime) / 1000;
+        currentStatus = getStatusPhrase(completedRequests, true);
+        currentAction = 'All packages installed';
+        displayProgress = 100;
+        currentSpeed = 0;
+        render(true);
+
+        process.stdout.write(SHOW_CURSOR);
+
+        console.log('');
+        if (code === 0) {
+            console.log(`${c.green}pipm${c.reset}${c.gray} |${c.reset} Installation complete (${completedRequests} packages in ${formatTime(elapsed)})`);
+        } else {
+            console.log(`${c.red}pipm${c.reset}${c.gray} |${c.reset} Installation failed with code ${code}`);
+        }
+        console.log('');
+        process.exit(code);
+    });
+
+    npm.on('error', (err) => {
+        clearInterval(updateInterval);
+        process.stdout.write(SHOW_CURSOR);
+        console.error(`${c.red}Failed to start npm: ${err.message}${c.reset}`);
+        process.exit(1);
+    });
+
+    process.on('SIGINT', () => {
+        clearInterval(updateInterval);
+        process.stdout.write(SHOW_CURSOR);
+        npm.kill('SIGINT');
+        process.exit(130);
+    });
+}
+
+main().catch((err) => {
+    process.stdout.write(SHOW_CURSOR);
+    console.error(`${c.red}Error: ${err.message}${c.reset}`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "pipm",
+    "version": "1.0.0",
+    "description": "A Python-inspired progress bar wrapper for npm that adds visibility and personality to your package installations",
+    "bin": {
+        "pipm": "bin/pipm.js"
+    },
+    "scripts": {
+        "test": "node bin/pipm.js install --help"
+    },
+    "keywords": [
+        "npm",
+        "pip",
+        "progress",
+        "cli",
+        "install",
+        "package-manager",
+        "wrapper"
+    ],
+    "author": "",
+    "license": "MIT",
+    "engines": {
+        "node": ">=14.0.0"
+    },
+    "files": [
+        "bin",
+        "README.md"
+    ],
+    "dependencies": {}
+}