pengushell 1.0.0

package/README.md

@@ -0,0 +1,195 @@
+# 🐧 PenguShell (pengushell)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![NPM Version](https://img.shields.io/npm/v/pengushell.svg)](https://www.npmjs.com/package/pengushell)
+
+A lightweight compatibility layer for Windows PowerShell that allows developers to run typical Linux/Unix commands natively. Written entirely in Node.js, PenguShell requires no external Linux binaries, WSL, or virtual machines, making it the perfect developer-experience enhancement tool on Windows.
+
+---
+
+## 🚀 Features
+
+- 🟢 **Native Node.js Implementation**: Completely portable cross-platform JavaScript under the hood.
+- 🔀 **Pipes & Streams**: Full standard stream pipe (`|`) support to chain commands (e.g. `cat file.log | grep Error`).
+- 📁 **Smart Path Conversion**: Automatic translation between Windows paths (e.g., `C:\Users\...`) and Linux style path syntax (e.g., `/c/users/...`).
+- ⚙️ **Recursive Alias Engine**: Expand shortcuts dynamically (e.g. `ll` to `ls -l`, `la` to `ls -la`) with built-in loop/cycle detection.
+- 🛠️ **Raw Mode Text Editor**: Built-in `nano` (MVP clone) with cursor navigation, modifications tracking, and safe file saving.
+- 🎨 **Hacker Green UI**: Highly readable, premium retro terminal styling powered by `chalk` with user toggling.
+- 🔍 **POSIX-Grade Grep**: Highly optimized searching, regular expressions support, matching highlights, line numbers, counting, and inversion.
+- ⌨️ **Tab Autocomplete**: Interactive command and file/folder path completions in the REPL.
+- 📜 **Persistent Session History**: Commands logged to `%APPDATA%/pengushell/history.log` to persist shell history across sessions.
+- 📂 **Wildcard Globbing**: Native pattern expansion (`*` and `?` wildcard operators) integrated directly into the parser.
+
+---
+
+## 📦 Installation
+
+To use PenguShell globally anywhere in your terminal, install it via NPM:
+
+```bash
+# Install globally
+npm install -g pengushell
+```
+
+Alternatively, you can run it directly using `npx`:
+
+```bash
+npx pengushell
+```
+
+---
+
+## 🎮 Usage
+
+PenguShell can be run in two modes:
+
+### 1. Interactive REPL Mode
+Running `pengushell` with no arguments starts an interactive session:
+```bash
+pengushell
+```
+**Example output:**
+```
+username@hostname:~$ ls -l
+drw-rw-rw- 1 user group        0 30/05/2026, 17:40:00 bin
+-rw-rw-rw- 1 user group      726 30/05/2026, 17:40:00 package.json
+```
+
+### 2. Direct Execution Mode
+Run a one-off compatibility command or pipeline and exit with standard codes:
+```bash
+pengushell ls -la
+pengushell "cat package.json | grep chalk"
+```
+
+### 3. Extended Shell Features
+PenguShell provides several built-in desktop terminal experiences natively:
+
+* **Native Wildcard Globbing**: Use standard pattern matching (`*` and `?` operators) for file parameters:
+  ```bash
+  # List all files ending in .json
+  pengushell ls *.json
+
+  # Find references to "chalk" in any package file
+  pengushell "grep chalk package*.json"
+  ```
+* **Command & Path Autocomplete**: In interactive REPL mode, press `Tab` once to view matching commands or double-tab to complete directory and file paths:
+  ```bash
+  user@hostname:~$ cd s[Tab]
+  # Completes automatically to:
+  user@hostname:~$ cd src/
+  ```
+* **Persistent Command History**: Command navigation is saved automatically. Hit the `Up` and `Down` arrow keys in the REPL to browse commands run in past terminal sessions. Logs are saved inside `%APPDATA%/pengushell/history.log`.
+
+---
+
+## 🛠️ Commands Reference
+
+| Command | Options | Description |
+| :--- | :--- | :--- |
+| **`ls`** | `-a`, `-l` | Lists directory contents with permissions, owner, sizes, and timestamps |
+| **`cd`** | `[path]` | Changes the current working directory (supports `~` home directory) |
+| **`pwd`** | None | Prints the current directory in Unix format |
+| **`cat`** | `-n` | Concatenates and displays files (reads from standard input if empty) |
+| **`mkdir`**| `-p` | Creates directories (ignores existing directories with `-p`) |
+| **`rm`** | `-r`, `-f` | Removes files and directories recursively and/or forcefully |
+| **`cp`** | `-r` | Copies files and directories recursively |
+| **`mv`** | None | Moves files and directories (handles cross-drive `EXDEV` copy-and-delete fallbacks) |
+| **`touch`**| None | Creates new files or updates access and modification timestamps |
+| **`grep`** | `-i`, `-v`, `-c`, `-n`, `-F` | Searches text streams/files using regular expressions or literals |
+| **`nano`** | `[file]` | MVP text editor with raw terminal inputs, save (`^O`), and exit (`^X`) |
+| **`clear`**| None | Resets the terminal screen output |
+| **`echo`** | `-n` | Prints text (omits trailing newline with `-n`) |
+| **`whoami`**| None | Outputs the current logged-in user name |
+| **`hostname`**| None | Prints the system host name |
+
+---
+
+## ⚙️ Configuration
+
+PenguShell generates a config file at:
+- **Windows**: `%APPDATA%/pengushell/config.json`
+- **macOS/Linux**: `~/.config/pengushell/config.json`
+
+### Interactive Configuration
+You can manage settings interactively:
+```bash
+pengushell config
+```
+
+### CLI Config Options
+```bash
+# View configuration settings and path
+pengushell config list
+
+# View only the config file location
+pengushell config path
+
+# Modify settings directly
+pengushell config set useColors false
+pengushell config set hackerGreenMode true
+```
+
+---
+
+## 💻 Development & Testing
+
+### Setup
+Clone the repository, install dependencies, and run:
+```bash
+git clone https://github.com/aneesh-srivastava-11/PenguShell.git
+cd PenguShell
+npm install
+```
+
+### Run Tests
+PenguShell includes a comprehensive test suite targeting lexing, parsing, configs, and command outputs:
+```bash
+npm test
+```
+
+### Local CLI Linking
+To link the command globally for local testing:
+```bash
+npm link
+```
+
+---
+
+## 📤 Publishing Instructions
+
+To publish your own version of `pengushell` to the NPM registry, execute:
+
+1. **Log in to NPM**:
+   ```bash
+   npm login
+   ```
+2. **Ensure Tests Pass**:
+   ```bash
+   npm test
+   ```
+3. **Bump Version** (Select major, minor, or patch):
+   ```bash
+   npm version patch
+   ```
+4. **Publish Package**:
+   ```bash
+   npm publish --access public
+   ```
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please follow these guidelines:
+1. Fork the repository.
+2. Create a feature branch (`git checkout -b feature/amazing-feature`).
+3. Commit your changes (`git commit -m 'Add amazing feature'`).
+4. Push to the branch (`git push origin feature/amazing-feature`).
+5. Open a Pull Request.
+
+---
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more information.

package/bin/pengushell.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { main } = require('../src/index');
+
+main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "pengushell",
+  "version": "1.0.0",
+  "description": "A professional developer-grade Linux command compatibility layer for Windows PowerShell.",
+  "main": "src/index.js",
+  "bin": {
+    "pengushell": "bin/pengushell.js"
+  },
+  "scripts": {
+    "test": "node tests/run.js"
+  },
+  "keywords": [
+    "cli",
+    "shell",
+    "powershell",
+    "windows",
+    "linux",
+    "compatibility",
+    "bash-on-windows"
+  ],
+  "author": "Developer",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.7.0"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "ora": "^5.4.1",
+    "prompts": "^2.4.2",
+    "zod": "^3.23.8"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/commands/filesystem.js

@@ -0,0 +1,266 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { toLinuxStyle, toWinStyle } = require('../utils/pathNormalizer');
+const { colorizePath, chalk } = require('../utils/colors');
+
+function resolvePath(targetPath) {
+  if (!targetPath) return process.cwd();
+  return path.resolve(toWinStyle(targetPath));
+}
+
+function getUnixPermissions(stat) {
+  const isDir = stat.isDirectory();
+  let perms = isDir ? 'd' : '-';
+  
+  const mode = stat.mode;
+  perms += (mode & 0o400) ? 'r' : '-';
+  perms += (mode & 0o200) ? 'w' : '-';
+  perms += (mode & 0o100) ? 'x' : '-';
+  perms += (mode & 0o040) ? 'r' : '-';
+  perms += (mode & 0o020) ? 'w' : '-';
+  perms += (mode & 0o010) ? 'x' : '-';
+  perms += (mode & 0o004) ? 'r' : '-';
+  perms += (mode & 0o002) ? 'w' : '-';
+  perms += (mode & 0o001) ? 'x' : '-';
+  
+  return perms;
+}
+
+module.exports = {
+  ls: {
+    name: 'ls',
+    execute({ args, flags, stdout }) {
+      const targets = args.length > 0 ? args : ['.'];
+      const results = [];
+
+      for (const arg of targets) {
+        const target = resolvePath(arg);
+        if (!fs.existsSync(target)) {
+          throw new Error(`ls: cannot access '${arg}': No such file or directory`);
+        }
+
+        const stat = fs.statSync(target);
+        if (!stat.isDirectory()) {
+          if (flags.l) {
+            const size = stat.size.toString().padStart(8);
+            const perms = getUnixPermissions(stat);
+            const nameColored = chalk.green(path.basename(target));
+            results.push(`${perms} 1 user group ${size} ${stat.mtime.toLocaleString()} ${nameColored}`);
+          } else {
+            results.push(chalk.green(path.basename(target)));
+          }
+          continue;
+        }
+
+        let entries = fs.readdirSync(target);
+        if (!flags.a) {
+          entries = entries.filter(e => !e.startsWith('.'));
+        }
+
+        const header = targets.length > 1 ? `${arg}:\n` : '';
+        const listOutput = [];
+
+        if (flags.l) {
+          for (const e of entries) {
+            const p = path.join(target, e);
+            let s;
+            try {
+              s = fs.statSync(p);
+            } catch (err) {
+              continue;
+            }
+            const isDir = s.isDirectory();
+            const size = s.size.toString().padStart(8);
+            const perms = getUnixPermissions(s); 
+            const nameColored = isDir ? colorizePath(e) : chalk.green(e);
+            listOutput.push(`${perms} 1 user group ${size} ${s.mtime.toLocaleString()} ${nameColored}`);
+          }
+        } else {
+          const coloredEntries = entries.map(e => {
+            const p = path.join(target, e);
+            let isDir = false;
+            try {
+              isDir = fs.statSync(p).isDirectory();
+            } catch (err) {}
+            return isDir ? colorizePath(e) : chalk.green(e);
+          });
+          listOutput.push(coloredEntries.join('  '));
+        }
+
+        results.push(header + listOutput.join('\n'));
+      }
+
+      stdout.write(results.join('\n\n') + '\n');
+    }
+  },
+
+  cat: {
+    name: 'cat',
+    execute({ args, flags, stdin, stdout }) {
+      if (args.length === 0) {
+        return new Promise((resolve) => {
+          const rl = readline.createInterface({
+            input: stdin,
+            crlfDelay: Infinity
+          });
+          let lineIdx = 1;
+          rl.on('line', (line) => {
+            if (flags.n) {
+              stdout.write(`  ${lineIdx++}  ${line}\n`);
+            } else {
+              stdout.write(line + '\n');
+            }
+          });
+          rl.on('close', () => {
+            resolve();
+          });
+        });
+      }
+
+      for (const f of args) {
+        const target = resolvePath(f);
+        if (!fs.existsSync(target)) {
+          throw new Error(`cat: ${f}: No such file or directory`);
+        }
+        if (fs.statSync(target).isDirectory()) {
+          throw new Error(`cat: ${f}: Is a directory`);
+        }
+        
+        const content = fs.readFileSync(target, 'utf8');
+        if (flags.n) {
+          const lines = content.split(/\r?\n/);
+          lines.forEach((l, idx) => stdout.write(`  ${idx + 1}  ${l}\n`));
+        } else {
+          stdout.write(content + '\n');
+        }
+      }
+    }
+  },
+
+  mkdir: {
+    name: 'mkdir',
+    execute({ args, flags }) {
+      if (args.length === 0) throw new Error(`mkdir: missing operand`);
+      for (const target of args) {
+        const fullPath = resolvePath(target);
+        try {
+          fs.mkdirSync(fullPath, { recursive: !!flags.p });
+        } catch (err) {
+          if (err.code === 'EEXIST' && flags.p) {
+            continue;
+          }
+          throw new Error(`mkdir: cannot create directory '${target}': ${err.message}`);
+        }
+      }
+    }
+  },
+
+  rm: {
+    name: 'rm',
+    execute({ args, flags }) {
+      if (args.length === 0) throw new Error(`rm: missing operand`);
+      for (const target of args) {
+        const fullPath = resolvePath(target);
+        if (!fs.existsSync(fullPath)) {
+          if (flags.f) continue;
+          throw new Error(`rm: cannot remove '${target}': No such file or directory`);
+        }
+        const st = fs.statSync(fullPath);
+        if (st.isDirectory()) {
+          if (!flags.r && !flags.R) {
+            throw new Error(`rm: cannot remove '${target}': Is a directory`);
+          }
+          fs.rmSync(fullPath, { recursive: true, force: !!flags.f });
+        } else {
+          fs.rmSync(fullPath, { force: !!flags.f });
+        }
+      }
+    }
+  },
+
+  touch: {
+    name: 'touch',
+    execute({ args }) {
+      if (args.length === 0) throw new Error(`touch: missing file operand`);
+      for (const target of args) {
+        const fullPath = resolvePath(target);
+        const time = new Date();
+        try {
+          if (fs.existsSync(fullPath)) {
+            fs.utimesSync(fullPath, time, time);
+          } else {
+            const parentDir = path.dirname(fullPath);
+            if (!fs.existsSync(parentDir)) {
+              throw new Error(`No such file or directory`);
+            }
+            fs.closeSync(fs.openSync(fullPath, 'w'));
+          }
+        } catch (err) {
+          throw new Error(`touch: cannot touch '${target}': ${err.message}`);
+        }
+      }
+    }
+  },
+
+  cp: {
+    name: 'cp',
+    execute({ args, flags }) {
+      if (args.length < 2) throw new Error(`cp: missing file operand`);
+      const dest = resolvePath(args[args.length - 1]);
+      const sources = args.slice(0, args.length - 1);
+      
+      const isDestDir = fs.existsSync(dest) && fs.statSync(dest).isDirectory();
+      if (sources.length > 1 && !isDestDir) {
+        throw new Error(`cp: target '${args[args.length - 1]}' is not a directory`);
+      }
+
+      for (const src of sources) {
+        const srcPath = resolvePath(src);
+        if (!fs.existsSync(srcPath)) {
+          throw new Error(`cp: cannot stat '${src}': No such file or directory`);
+        }
+        const st = fs.statSync(srcPath);
+        const destPath = isDestDir ? path.join(dest, path.basename(srcPath)) : dest;
+        if (st.isDirectory()) {
+          if (!flags.r && !flags.R) throw new Error(`cp: -r not specified; omitting directory '${src}'`);
+          fs.cpSync(srcPath, destPath, { recursive: true });
+        } else {
+          fs.copyFileSync(srcPath, destPath);
+        }
+      }
+    }
+  },
+
+  mv: {
+    name: 'mv',
+    execute({ args }) {
+      if (args.length < 2) throw new Error(`mv: missing file operand`);
+      const dest = resolvePath(args[args.length - 1]);
+      const sources = args.slice(0, args.length - 1);
+
+      const isDestDir = fs.existsSync(dest) && fs.statSync(dest).isDirectory();
+      if (sources.length > 1 && !isDestDir) {
+        throw new Error(`mv: target '${args[args.length - 1]}' is not a directory`);
+      }
+
+      for (const src of sources) {
+        const srcPath = resolvePath(src);
+        if (!fs.existsSync(srcPath)) {
+          throw new Error(`mv: cannot stat '${src}': No such file or directory`);
+        }
+        const destPath = isDestDir ? path.join(dest, path.basename(srcPath)) : dest;
+        try {
+          fs.renameSync(srcPath, destPath);
+        } catch (err) {
+          if (err.code === 'EXDEV') {
+            fs.cpSync(srcPath, destPath, { recursive: true });
+            fs.rmSync(srcPath, { recursive: true, force: true });
+          } else {
+            throw new Error(`mv: cannot move '${src}' to '${destPath}': ${err.message}`);
+          }
+        }
+      }
+    }
+  }
+};