pengushell 1.0.0

package/src/core/parser.js

@@ -0,0 +1,160 @@
+const fs = require('fs');
+const path = require('path');
+const { tokenize } = require('./lexer');
+const { loadConfig } = require('../config/defaults');
+const { toWinStyle } = require('../utils/pathNormalizer');
+
+function expandGlob(arg, cwd = process.cwd()) {
+  if (!arg.includes('*') && !arg.includes('?')) {
+    return [arg];
+  }
+  
+  let normalized = arg.replace(/\\/g, '/');
+  let isDriveMapped = false;
+  
+  if (normalized.match(/^\/[a-zA-Z]\//) || normalized.match(/^\/[a-zA-Z]$/)) {
+    cwd = toWinStyle(normalized.substring(0, 3));
+    normalized = normalized.substring(3);
+    isDriveMapped = true;
+  }
+
+  const parts = normalized.split('/').filter(p => p !== '');
+  let currentDirs = [cwd];
+  
+  if (path.isAbsolute(arg) && !isDriveMapped) {
+    currentDirs = [path.parse(arg).root];
+  }
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === '.' || part === '..') {
+      currentDirs = currentDirs.map(d => path.resolve(d, part));
+      continue;
+    }
+    
+    if (!part.includes('*') && !part.includes('?')) {
+      currentDirs = currentDirs
+        .map(d => path.join(d, part))
+        .filter(p => fs.existsSync(p));
+      continue;
+    }
+    
+    const regexStr = '^' + part
+      .replace(/[-\/\\^$+?.()|[\]{}]/g, '\\$&')
+      .replace(/\*/g, '.*')
+      .replace(/\?/g, '.') + '$';
+    const regex = new RegExp(regexStr, 'i');
+    
+    const nextDirs = [];
+    for (const dir of currentDirs) {
+      if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) continue;
+      try {
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+          if (regex.test(entry)) {
+            nextDirs.push(path.join(dir, entry));
+          }
+        }
+      } catch (err) {}
+    }
+    currentDirs = nextDirs;
+  }
+  
+  if (currentDirs.length === 0) {
+    return [arg];
+  }
+  
+  return currentDirs.map(p => {
+    if (path.isAbsolute(arg)) return p;
+    const rel = path.relative(process.cwd(), p);
+    return rel || '.';
+  });
+}
+
+function expandAliases(tokens, aliases, expanded = new Set()) {
+  const result = [];
+  let isCommandStart = true;
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === '|') {
+      result.push(token);
+      isCommandStart = true;
+      continue;
+    }
+
+    if (isCommandStart) {
+      isCommandStart = false;
+      if (aliases[token] && !expanded.has(token)) {
+        expanded.add(token);
+        const aliasTokens = tokenize(aliases[token]);
+        const expandedAlias = expandAliases(aliasTokens, aliases, new Set(expanded));
+        result.push(...expandedAlias);
+        continue;
+      }
+    }
+
+    result.push(token);
+  }
+  return result;
+}
+
+function parsePipeline(input) {
+  let tokens = tokenize(input);
+  if (tokens.length === 0) return [];
+
+  const config = loadConfig();
+  if (config && config.aliases) {
+    tokens = expandAliases(tokens, config.aliases);
+  }
+
+  const pipeline = [];
+  let currentCmd = null;
+
+  for (const token of tokens) {
+    if (token === '|') {
+      if (currentCmd) {
+        pipeline.push(currentCmd);
+        currentCmd = null;
+      }
+      continue;
+    }
+
+    if (!currentCmd) {
+      currentCmd = {
+        command: token,
+        args: [],
+        rawArgs: [],
+        flags: {}
+      };
+      continue;
+    }
+
+    if (token.startsWith('--')) {
+      currentCmd.rawArgs.push(token);
+      const parts = token.slice(2).split('=');
+      const flagName = parts[0];
+      const flagValue = parts.length > 1 ? parts.slice(1).join('=') : true;
+      currentCmd.flags[flagName] = flagValue;
+    } else if (token.startsWith('-') && token !== '-' && token !== '--') {
+      currentCmd.rawArgs.push(token);
+      const flags = token.slice(1);
+      for (const f of flags) {
+        currentCmd.flags[f] = true;
+      }
+    } else {
+      // Positional argument - expand wildcards
+      const expanded = expandGlob(token);
+      currentCmd.args.push(...expanded);
+      currentCmd.rawArgs.push(...expanded);
+    }
+  }
+
+  if (currentCmd) {
+    pipeline.push(currentCmd);
+  }
+
+  return pipeline;
+}
+
+module.exports = { parsePipeline };

package/src/core/repl.js

@@ -0,0 +1,148 @@
+const readline = require('readline');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { hackerGreen, errorMsg, chalk } = require('../utils/colors');
+const { toLinuxStyle, toWinStyle } = require('../utils/pathNormalizer');
+const { parsePipeline } = require('./parser');
+const { executePipeline } = require('./executor');
+const { configFile } = require('../config/defaults');
+
+const configDir = path.dirname(configFile);
+const historyFile = path.join(configDir, 'history.log');
+
+function getPrompt() {
+  const username = os.userInfo().username;
+  const hostname = os.hostname();
+  const rawCwd = process.cwd();
+  const homeDir = os.homedir();
+  
+  let linuxCwd = toLinuxStyle(rawCwd);
+  const linuxHome = toLinuxStyle(homeDir);
+
+  if (linuxCwd.startsWith(linuxHome)) {
+    linuxCwd = linuxCwd.replace(linuxHome, '~');
+  }
+
+  const promptText = `${username}@${hostname}:${linuxCwd}$ `;
+  return hackerGreen(promptText);
+}
+
+// Tab completion function
+function completer(line) {
+  const builtins = [
+    'ls', 'cd', 'pwd', 'clear', 'echo', 'whoami', 
+    'hostname', 'cat', 'mkdir', 'rm', 'cp', 'mv', 
+    'touch', 'grep', 'nano', 'config', 'exit'
+  ];
+  
+  const parts = line.split(/\s+/);
+  
+  // 1. Autocomplete commands if typing the first word
+  if (parts.length <= 1) {
+    const hits = builtins.filter(c => c.startsWith(line));
+    return [hits.length ? hits : builtins, line];
+  }
+  
+  // 2. Autocomplete files/folders for parameters
+  const lastArg = parts[parts.length - 1];
+  let dir = '.';
+  let prefix = lastArg;
+  
+  if (lastArg.includes('/') || lastArg.includes('\\')) {
+    const normalized = lastArg.replace(/\\/g, '/');
+    const slashIndex = normalized.lastIndexOf('/');
+    dir = lastArg.substring(0, slashIndex);
+    prefix = lastArg.substring(slashIndex + 1);
+    if (dir === '') dir = '/';
+  }
+  
+  try {
+    const resolvedDir = path.resolve(toWinStyle(dir));
+    if (fs.existsSync(resolvedDir) && fs.statSync(resolvedDir).isDirectory()) {
+      const entries = fs.readdirSync(resolvedDir);
+      const hits = entries
+        .filter(f => f.startsWith(prefix))
+        .map(f => {
+          const joined = path.join(dir, f).replace(/\\/g, '/');
+          try {
+            if (fs.statSync(path.join(resolvedDir, f)).isDirectory()) {
+              return joined + '/'; // Directory trailer
+            }
+          } catch (e) {}
+          return joined;
+        });
+        
+      return [hits, lastArg];
+    }
+  } catch (e) {
+    // Fail silently, returning empty completions
+  }
+  
+  return [[], lastArg];
+}
+
+function startRepl() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: getPrompt(),
+    completer: completer, // Enable autocomplete
+    historySize: 1000
+  });
+
+  // Seed history from file
+  if (fs.existsSync(historyFile)) {
+    try {
+      const historyLines = fs.readFileSync(historyFile, 'utf8')
+        .split(/\r?\n/)
+        .filter(l => l.trim().length > 0)
+        .reverse(); // Readline expects newest commands first
+      rl.history = historyLines;
+    } catch (err) {}
+  }
+
+  console.log(hackerGreen('PenguShell v1.0.0 - Windows Compatibility Layer'));
+  console.log(hackerGreen('Type "exit" to quit. (Tab-completion and history enabled)'));
+  
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    line = line.trim();
+    if (line === 'exit') {
+      rl.close();
+      return;
+    }
+
+    if (line.length > 0) {
+      // Append to persistent history log
+      try {
+        fs.appendFileSync(historyFile, line + '\n');
+      } catch (err) {}
+
+      try {
+        rl.pause();
+        const pipeline = parsePipeline(line);
+        await executePipeline(pipeline, process.stdin, process.stdout);
+      } catch (err) {
+        console.error(errorMsg(`pengushell: ${err.message}`));
+      } finally {
+        rl.resume();
+      }
+    }
+    
+    rl.setPrompt(getPrompt());
+    rl.prompt();
+  }).on('close', () => {
+    console.log(hackerGreen('exit'));
+    process.exit(0);
+  });
+  
+  rl.on('SIGINT', () => {
+    rl.write('^C\n');
+    rl.setPrompt(getPrompt());
+    rl.prompt();
+  });
+}
+
+module.exports = { startRepl };

package/src/index.js

@@ -0,0 +1,142 @@
+const { loadConfig, saveConfig, configFile } = require('./config/defaults');
+const { startRepl } = require('./core/repl');
+const { parsePipeline } = require('./core/parser');
+const { executePipeline } = require('./core/executor');
+const { chalk, errorMsg, hackerGreen } = require('./utils/colors');
+const prompts = require('prompts');
+
+function printHelp() {
+  console.log(hackerGreen('PenguShell - Windows PowerShell Compatibility Layer'));
+  console.log('\nUsage:');
+  console.log('  pengushell                    Start interactive shell (REPL)');
+  console.log('  pengushell <command> [args]   Execute command directly and exit');
+  console.log('  pengushell config [action]    Manage configuration');
+  console.log('\nConfig Actions:');
+  console.log('  interactive                   Start interactive config manager (default)');
+  console.log('  list / show                   Display current configuration settings');
+  console.log('  path                          Print the path of the config file');
+  console.log('  set <key> <value>             Update a specific configuration value');
+  console.log('\nOptions:');
+  console.log('  -h, --help                    Show this help message');
+  console.log('  -v, --version                 Show version info');
+  console.log('\nBuilt-in Commands:');
+  console.log('  ls, pwd, cd, clear, echo, whoami, hostname, cat, mkdir, rm, cp, mv, touch, grep, nano');
+}
+
+async function interactiveConfig() {
+  const current = loadConfig();
+  const response = await prompts([
+    {
+      type: 'toggle',
+      name: 'useColors',
+      message: 'Enable colorized output?',
+      initial: current.useColors,
+      active: 'yes',
+      inactive: 'no'
+    },
+    {
+      type: 'toggle',
+      name: 'hackerGreenMode',
+      message: 'Enable hacker green terminal styling?',
+      initial: current.hackerGreenMode,
+      active: 'yes',
+      inactive: 'no'
+    }
+  ]);
+  
+  if (response.useColors !== undefined && response.hackerGreenMode !== undefined) {
+    const updated = {
+      ...current,
+      useColors: response.useColors,
+      hackerGreenMode: response.hackerGreenMode
+    };
+    saveConfig(updated);
+    console.log(chalk.green('✔ Configuration saved successfully!'));
+  } else {
+    console.log(chalk.yellow('Configuration changes cancelled.'));
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // 1. Version Check
+  if (args.includes('-v') || args.includes('--version')) {
+    console.log(`PenguShell v${require('../package.json').version}`);
+    process.exit(0);
+  }
+
+  // 2. Help Check
+  if (args.includes('-h') || args.includes('--help')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  // 3. Config Subcommands
+  if (args[0] === 'config') {
+    const configAction = args[1];
+    if (!configAction || configAction === 'interactive') {
+      await interactiveConfig();
+    } else if (configAction === 'list' || configAction === 'show') {
+      const current = loadConfig();
+      console.log(chalk.cyan(`Config file: ${configFile}`));
+      console.log(JSON.stringify(current, null, 2));
+    } else if (configAction === 'path') {
+      console.log(configFile);
+    } else if (configAction === 'set') {
+      const key = args[2];
+      const val = args[3];
+      if (!key || val === undefined) {
+        console.error(errorMsg('Usage: pengushell config set <key> <value>'));
+        process.exit(1);
+      }
+      const current = loadConfig();
+      let typedVal = val;
+      if (val === 'true') typedVal = true;
+      if (val === 'false') typedVal = false;
+      
+      current[key] = typedVal;
+      if (saveConfig(current)) {
+        console.log(chalk.green(`✔ Saved ${key} = ${typedVal}`));
+      } else {
+        console.error(errorMsg('Failed to save config.'));
+        process.exit(1);
+      }
+    } else {
+      console.error(errorMsg(`Unknown config command: ${configAction}`));
+      console.log('Available config actions: interactive, list, path, set');
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  // 4. Start REPL Mode
+  if (args.length === 0) {
+    startRepl();
+    return;
+  }
+
+  // 5. Direct Execution Mode (e.g. pengushell ls -la)
+  let cmdString;
+  if (args.length === 1) {
+    cmdString = args[0];
+  } else {
+    cmdString = args.map(arg => {
+      if (arg.includes(' ') || arg.includes('|') || arg.includes('>') || arg.includes('<')) {
+        return `"${arg.replace(/"/g, '\\"')}"`;
+      }
+      return arg;
+    }).join(' ');
+  }
+
+  try {
+    const pipeline = parsePipeline(cmdString);
+    await executePipeline(pipeline, process.stdin, process.stdout);
+    process.exit(process.exitCode !== undefined ? process.exitCode : 0);
+  } catch (err) {
+    console.error(errorMsg(`pengushell: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+module.exports = { main };

package/src/registry/commandRegistry.js

@@ -0,0 +1,24 @@
+const systemCmds = require('../commands/system');
+const fsCmds = require('../commands/filesystem');
+const searchCmds = require('../commands/search');
+const nanoCmd = require('../commands/nano');
+
+const registry = {
+  ...systemCmds,
+  ...fsCmds,
+  ...searchCmds,
+  ...nanoCmd
+};
+
+function getCommand(name) {
+  return registry[name] || null;
+}
+
+function registerCommand(name, cmdObj) {
+  registry[name] = cmdObj;
+}
+
+module.exports = {
+  getCommand,
+  registerCommand
+};

package/src/utils/colors.js

@@ -0,0 +1,29 @@
+const chalk = require('chalk');
+const { loadConfig } = require('../config/defaults');
+
+const config = loadConfig();
+if (!config.useColors) {
+  chalk.level = 0;
+}
+
+function hackerGreen(text) {
+  if (config.hackerGreenMode) {
+    return chalk.bgBlack.greenBright(text);
+  }
+  return chalk.greenBright(text);
+}
+
+function colorizePath(pathStr) {
+  return chalk.blueBright(pathStr);
+}
+
+function errorMsg(text) {
+  return chalk.red(text);
+}
+
+module.exports = {
+  hackerGreen,
+  colorizePath,
+  errorMsg,
+  chalk
+};

package/src/utils/pathNormalizer.js

@@ -0,0 +1,56 @@
+const path = require('path');
+
+// Convert C:\Users\name to /c/Users/name
+function toLinuxStyle(winPath) {
+  if (!winPath) return '/';
+  
+  // Normalize slashes
+  let linuxPath = winPath.replace(/\\/g, '/');
+  
+  // Handle drive letter C:/ -> /c/
+  const driveMatch = linuxPath.match(/^([a-zA-Z]):\/(.*)$/);
+  if (driveMatch) {
+    const drive = driveMatch[1].toLowerCase();
+    const rest = driveMatch[2];
+    linuxPath = `/${drive}/${rest}`;
+  } else {
+    const driveMatchRoot = linuxPath.match(/^([a-zA-Z]):$/);
+    if(driveMatchRoot) {
+        linuxPath = `/${driveMatchRoot[1].toLowerCase()}`;
+    }
+  }
+  
+  // Remove trailing slash unless it's just root
+  if (linuxPath.length > 1 && linuxPath.endsWith('/')) {
+    linuxPath = linuxPath.slice(0, -1);
+  }
+  
+  return linuxPath;
+}
+
+// Convert /c/Users/name to C:\Users\name
+function toWinStyle(linuxPath) {
+  if (!linuxPath) return process.cwd();
+  
+  // Convert /c/ to C:\
+  const driveMatch = linuxPath.match(/^\/([a-zA-Z])(?:\/(.*))?$/);
+  if (driveMatch) {
+    const drive = driveMatch[1].toUpperCase();
+    const rest = driveMatch[2] || '';
+    return path.normalize(`${drive}:\\${rest}`);
+  }
+  
+  // If it's just / return current drive root (assuming C:\ as default)
+  if (linuxPath === '/') {
+    const currentDrive = path.parse(process.cwd()).root;
+    return currentDrive;
+  }
+  
+  // Otherwise, probably relative, just normalize
+  return path.normalize(linuxPath);
+}
+
+module.exports = {
+  toLinuxStyle,
+  toWinStyle
+};