pengushell 1.0.0

package/src/commands/nano.js

@@ -0,0 +1,250 @@
+const fs = require('fs');
+const path = require('path');
+const { chalk } = require('../utils/colors');
+const { toWinStyle } = require('../utils/pathNormalizer');
+
+const KEYS = {
+  CTRL_X: '\u0018',
+  CTRL_O: '\u000f',
+  CTRL_C: '\u0003',
+  UP: '\u001b[A',
+  DOWN: '\u001b[B',
+  RIGHT: '\u001b[C',
+  LEFT: '\u001b[D',
+  BACKSPACE: '\b',
+  BACKSPACE2: '\x7f',
+  ENTER: '\r',
+  DELETE: '\u001b[3~'
+};
+
+module.exports = {
+  nano: {
+    name: 'nano',
+    execute({ args, stdin, stdout }) {
+      return new Promise((resolve, reject) => {
+        let filePath = args[0];
+        let fullPath = null;
+        let buffer = [''];
+        let cursorX = 0;
+        let cursorY = 0;
+        let isModified = false;
+        let promptMode = false;
+        let promptMessage = '';
+        let promptCallback = null;
+        let statusMessage = '';
+
+        if (filePath) {
+          fullPath = path.resolve(toWinStyle(filePath));
+          if (fs.existsSync(fullPath)) {
+            try {
+              const content = fs.readFileSync(fullPath, 'utf8');
+              buffer = content.split(/\r?\n/);
+              if (buffer.length === 0) buffer = [''];
+            } catch (e) {
+              reject(new Error(`nano: ${e.message}`));
+              return;
+            }
+          }
+        }
+
+        const getTerminalSize = () => {
+          return {
+            columns: stdout.columns || 80,
+            rows: stdout.rows || 24
+          };
+        };
+
+        const render = () => {
+          stdout.write('\x1bc');
+          const { columns, rows } = getTerminalSize();
+          
+          const header = `  PENGU NANO 1.0     ${filePath || 'New Buffer'}     ${isModified ? '*' : ' '}`;
+          stdout.write(chalk.bgBlack.greenBright(header.padEnd(columns)) + '\n');
+
+          const availableRows = rows - 4;
+          for (let i = 0; i < availableRows; i++) {
+            if (i < buffer.length) {
+              stdout.write(`${buffer[i]}\x1b[K\n`);
+            } else {
+              stdout.write(`\x1b[K\n`);
+            }
+          }
+
+          if (promptMode) {
+            stdout.write(`\x1b[K\n${chalk.greenBright(promptMessage)}\n`);
+          } else {
+            const footerText = statusMessage || `^X Exit   ^O Save   ^C Cancel`;
+            stdout.write(`\x1b[K\n${chalk.bgBlack.greenBright(footerText.padEnd(columns))}\n`);
+          }
+
+          stdout.write(`\x1b[${cursorY + 2};${cursorX + 1}H`);
+        };
+
+        const exitNano = () => {
+          if (stdin.isTTY) stdin.setRawMode(false);
+          stdin.removeListener('data', onData);
+          stdout.write('\x1bc'); 
+          resolve();
+        };
+
+        const saveFile = () => {
+          if (!fullPath) {
+            promptMode = true;
+            promptMessage = 'File Name to Write: ';
+            promptCallback = (input) => {
+              if (input) {
+                filePath = input;
+                fullPath = path.resolve(toWinStyle(filePath));
+                try {
+                  fs.writeFileSync(fullPath, buffer.join('\n'));
+                  isModified = false;
+                  statusMessage = `[ Wrote ${buffer.length} lines ]`;
+                } catch (err) {
+                  statusMessage = `[ Error saving file: ${err.message} ]`;
+                }
+              }
+              promptMode = false;
+              render();
+              setTimeout(() => { statusMessage = ''; render(); }, 2000);
+            };
+          } else {
+            try {
+              fs.writeFileSync(fullPath, buffer.join('\n'));
+              isModified = false;
+              statusMessage = `[ Wrote ${buffer.length} lines ]`;
+            } catch (err) {
+              statusMessage = `[ Error saving file: ${err.message} ]`;
+            }
+            render();
+            setTimeout(() => { statusMessage = ''; render(); }, 2000);
+          }
+        };
+
+        if (stdin.isTTY) {
+          stdin.setRawMode(true);
+        }
+        
+        let promptInputBuffer = '';
+
+        const onData = (data) => {
+          const char = data.toString('utf8');
+
+          if (promptMode) {
+            if (char === KEYS.ENTER) {
+              const ans = promptInputBuffer;
+              promptInputBuffer = '';
+              promptCallback(ans.trim());
+            } else if (char === KEYS.CTRL_C) {
+              promptMode = false;
+              promptInputBuffer = '';
+              render();
+            } else if (char === KEYS.BACKSPACE || char === KEYS.BACKSPACE2) {
+              promptInputBuffer = promptInputBuffer.slice(0, -1);
+              promptMessage = promptMessage.substring(0, promptMessage.lastIndexOf(':') + 2) + promptInputBuffer;
+              render();
+            } else {
+              if (char.length > 1 && char.startsWith('\u001b')) return;
+              promptInputBuffer += char;
+              promptMessage += char;
+              render();
+            }
+            return;
+          }
+
+          if (char === KEYS.CTRL_C) {
+            if (isModified) {
+              promptMode = true;
+              promptMessage = "Save modified buffer? (Y/N): ";
+              promptCallback = (ans) => {
+                if (ans.toLowerCase() === 'y') {
+                  saveFile();
+                  exitNano();
+                } else if (ans.toLowerCase() === 'n') {
+                  exitNano();
+                } else {
+                  promptMode = false;
+                  render();
+                }
+              };
+              render();
+            } else {
+              exitNano();
+            }
+          } else if (char === KEYS.CTRL_X) {
+            if (isModified) {
+              promptMode = true;
+              promptMessage = "Save modified buffer? (Y/N): ";
+              promptCallback = (ans) => {
+                if (ans.toLowerCase() === 'y') {
+                  saveFile();
+                  exitNano();
+                } else if (ans.toLowerCase() === 'n') {
+                  exitNano();
+                } else {
+                  promptMode = false;
+                  render();
+                }
+              };
+              render();
+            } else {
+              exitNano();
+            }
+          } else if (char === KEYS.CTRL_O) {
+            saveFile();
+          } else if (char === KEYS.UP) {
+            if (cursorY > 0) cursorY--;
+            cursorX = Math.min(cursorX, buffer[cursorY].length);
+          } else if (char === KEYS.DOWN) {
+            if (cursorY < buffer.length - 1) cursorY++;
+            cursorX = Math.min(cursorX, buffer[cursorY].length);
+          } else if (char === KEYS.LEFT) {
+            if (cursorX > 0) cursorX--;
+            else if (cursorY > 0) {
+              cursorY--;
+              cursorX = buffer[cursorY].length;
+            }
+          } else if (char === KEYS.RIGHT) {
+            if (cursorX < buffer[cursorY].length) cursorX++;
+            else if (cursorY < buffer.length - 1) {
+              cursorY++;
+              cursorX = 0;
+            }
+          } else if (char === KEYS.BACKSPACE || char === KEYS.BACKSPACE2) {
+            if (cursorX > 0) {
+              const line = buffer[cursorY];
+              buffer[cursorY] = line.slice(0, cursorX - 1) + line.slice(cursorX);
+              cursorX--;
+              isModified = true;
+            } else if (cursorY > 0) {
+              const prevLen = buffer[cursorY - 1].length;
+              buffer[cursorY - 1] += buffer[cursorY];
+              buffer.splice(cursorY, 1);
+              cursorY--;
+              cursorX = prevLen;
+              isModified = true;
+            }
+          } else if (char === KEYS.ENTER) {
+            const line = buffer[cursorY];
+            const nextLine = line.slice(cursorX);
+            buffer[cursorY] = line.slice(0, cursorX);
+            buffer.splice(cursorY + 1, 0, nextLine);
+            cursorY++;
+            cursorX = 0;
+            isModified = true;
+          } else {
+            if (char.length > 1 && char.startsWith('\u001b')) return;
+            
+            const line = buffer[cursorY] || '';
+            buffer[cursorY] = line.slice(0, cursorX) + char + line.slice(cursorX);
+            cursorX += char.length;
+            isModified = true;
+          }
+          render();
+        };
+
+        render();
+        stdin.on('data', onData);
+      });
+    }
+  }
+};

package/src/commands/search.js

@@ -0,0 +1,98 @@
+const fs = require('fs');
+const readline = require('readline');
+const { chalk } = require('../utils/colors');
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = {
+  grep: {
+    name: 'grep',
+    async execute({ args, flags, stdin, stdout }) {
+      if (args.length === 0) {
+        throw new Error('grep: missing pattern');
+      }
+
+      let pattern = args[0];
+      const files = args.slice(1);
+      
+      const isRegex = !flags.F;
+      if (!isRegex) {
+        pattern = escapeRegExp(pattern);
+      }
+
+      let regex;
+      try {
+        const regexOpts = flags.i ? 'gi' : 'g';
+        regex = new RegExp(pattern, regexOpts);
+      } catch (err) {
+        throw new Error(`grep: invalid regular expression: ${err.message}`);
+      }
+      
+      const useColor = flags.color === 'always' || flags.color === 'auto' || (flags.color !== 'never' && chalk.level > 0);
+
+      const highlight = (line) => {
+        return line.replace(regex, match => chalk.red.bold(match));
+      };
+
+      const processStream = async (inputStream, prefix = '') => {
+        const rl = readline.createInterface({
+          input: inputStream,
+          crlfDelay: Infinity
+        });
+
+        let lineCounter = 1;
+        let matchCount = 0;
+
+        for await (const line of rl) {
+          regex.lastIndex = 0;
+          const matched = regex.test(line);
+          const shouldExclude = !!flags.v;
+          
+          if (matched !== shouldExclude) {
+            matchCount++;
+            if (!flags.c) {
+              let outLine = flags.n ? `${chalk.yellow(lineCounter)}: ` : '';
+              outLine += useColor ? highlight(line) : line;
+              stdout.write(`${prefix}${outLine}\n`);
+            }
+          }
+          lineCounter++;
+        }
+
+        if (flags.c) {
+          stdout.write(`${prefix}${matchCount}\n`);
+        }
+        
+        return matchCount > 0;
+      };
+
+      let exitWithSuccess = false;
+
+      if (files.length === 0) {
+        exitWithSuccess = await processStream(stdin);
+      } else {
+        const showPrefix = files.length > 1;
+        for (const file of files) {
+          if (!fs.existsSync(file)) {
+            stdout.write(`grep: ${file}: No such file or directory\n`);
+            continue;
+          }
+          if (fs.statSync(file).isDirectory()) {
+            stdout.write(`grep: ${file}: Is a directory\n`);
+            continue;
+          }
+          const stream = fs.createReadStream(file);
+          const pref = showPrefix ? `${chalk.blueBright(file)}: ` : '';
+          const hasMatches = await processStream(stream, pref);
+          if (hasMatches) {
+            exitWithSuccess = true;
+          }
+        }
+      }
+
+      process.exitCode = exitWithSuccess ? 0 : 1;
+    }
+  }
+};

package/src/commands/system.js

@@ -0,0 +1,66 @@
+const os = require('os');
+const path = require('path');
+const { toLinuxStyle, toWinStyle } = require('../utils/pathNormalizer');
+
+module.exports = {
+  pwd: {
+    name: 'pwd',
+    execute({ stdout }) {
+      stdout.write(toLinuxStyle(process.cwd()) + '\n');
+    }
+  },
+  
+  cd: {
+    name: 'cd',
+    execute({ args }) {
+      let target = args[0];
+      try {
+        if (!target) {
+          target = os.homedir();
+        } else if (target === '~') {
+          target = os.homedir();
+        } else if (target.startsWith('~/') || target.startsWith('~\\')) {
+          target = path.join(os.homedir(), target.slice(2));
+        } else {
+          target = toWinStyle(target);
+        }
+        process.chdir(target);
+      } catch (err) {
+        throw new Error(`cd: ${target || ''}: No such file or directory`);
+      }
+    }
+  },
+
+  clear: {
+    name: 'clear',
+    execute() {
+      process.stdout.write('\x1bc');
+    }
+  },
+
+  echo: {
+    name: 'echo',
+    execute({ args, flags, stdout }) {
+      const output = args.join(' ');
+      if (flags.n) {
+        stdout.write(output);
+      } else {
+        stdout.write(output + '\n');
+      }
+    }
+  },
+
+  whoami: {
+    name: 'whoami',
+    execute({ stdout }) {
+      stdout.write(os.userInfo().username + '\n');
+    }
+  },
+
+  hostname: {
+    name: 'hostname',
+    execute({ stdout }) {
+      stdout.write(os.hostname() + '\n');
+    }
+  }
+};

package/src/config/defaults.js

@@ -0,0 +1,70 @@
+const fs = require('fs');
+const path = require('path');
+const { z } = require('zod');
+
+const appDataPath = process.env.APPDATA || (process.platform === 'darwin' ? path.join(process.env.HOME, 'Library/Preferences') : path.join(process.env.HOME, '.local/share'));
+const configDir = path.join(appDataPath, 'pengushell');
+const configFile = path.join(configDir, 'config.json');
+
+// Define validation schema using Zod
+const configSchema = z.object({
+  useColors: z.boolean().default(true),
+  hackerGreenMode: z.boolean().default(true),
+  aliases: z.record(z.string()).default({
+    "ll": "ls -l",
+    "la": "ls -la"
+  })
+});
+
+const defaultSettings = {
+  useColors: true,
+  hackerGreenMode: true,
+  aliases: {
+    "ll": "ls -l",
+    "la": "ls -la"
+  }
+};
+
+function loadConfig() {
+  if (!fs.existsSync(configDir)) {
+    try {
+      fs.mkdirSync(configDir, { recursive: true });
+    } catch (err) {
+      // Fallback
+    }
+  }
+  if (!fs.existsSync(configFile)) {
+    try {
+      fs.writeFileSync(configFile, JSON.stringify(defaultSettings, null, 2));
+    } catch (err) {
+      // Fallback
+    }
+    return defaultSettings;
+  }
+  try {
+    const data = fs.readFileSync(configFile, 'utf8');
+    const parsed = JSON.parse(data);
+    return configSchema.parse(parsed);
+  } catch (err) {
+    return defaultSettings;
+  }
+}
+
+function saveConfig(settings) {
+  try {
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    const validated = configSchema.parse(settings);
+    fs.writeFileSync(configFile, JSON.stringify(validated, null, 2));
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  configFile
+};

package/src/core/executor.js

@@ -0,0 +1,110 @@
+const { getCommand } = require('../registry/commandRegistry');
+const { PassThrough } = require('stream');
+const { spawn } = require('child_process');
+
+function runSystemFallback(parsedParams, stdin, stdout, stderr, isSingleCommand) {
+  return new Promise((resolve) => {
+    const stdioOpt = isSingleCommand
+      ? ['inherit', 'inherit', 'inherit']
+      : ['pipe', 'pipe', 'inherit'];
+
+    const child = spawn(parsedParams.command, parsedParams.rawArgs, {
+      stdio: stdioOpt,
+      shell: true
+    });
+
+    if (!isSingleCommand) {
+      if (stdin !== process.stdin && stdin) {
+        stdin.pipe(child.stdin);
+      }
+
+      child.stdout.on('data', (data) => {
+        stdout.write(data);
+      });
+    }
+
+    child.on('close', (code) => {
+      if (!isSingleCommand && stdout !== process.stdout && typeof stdout.end === 'function') {
+        stdout.end();
+      }
+      resolve(code);
+    });
+
+    child.on('error', (err) => {
+      stderr.write(`pengushell: command not found: ${parsedParams.command}\n`);
+      if (!isSingleCommand && stdout !== process.stdout && typeof stdout.end === 'function') {
+        stdout.end();
+      }
+      resolve(1);
+    });
+  });
+}
+
+async function executePipeline(pipeline, processStdin, processStdout) {
+  if (!pipeline || pipeline.length === 0) return;
+
+  if (pipeline.length === 1) {
+    const parsedParams = pipeline[0];
+    const cmd = getCommand(parsedParams.command);
+
+    if (!cmd) {
+      await runSystemFallback(parsedParams, processStdin, processStdout, processStdout, true);
+      return;
+    }
+
+    await cmd.execute({
+      args: parsedParams.args,
+      rawArgs: parsedParams.rawArgs,
+      flags: parsedParams.flags,
+      stdin: processStdin,
+      stdout: processStdout,
+      stderr: processStdout
+    });
+    return;
+  }
+
+  const streams = [processStdin];
+  for (let i = 0; i < pipeline.length - 1; i++) {
+    streams.push(new PassThrough());
+  }
+  streams.push(processStdout);
+
+  const promises = [];
+  for (let i = 0; i < pipeline.length; i++) {
+    const parsedParams = pipeline[i];
+    const cmd = getCommand(parsedParams.command);
+    const cmdStdin = streams[i];
+    const cmdStdout = streams[i + 1];
+
+    if (!cmd) {
+      promises.push(runSystemFallback(parsedParams, cmdStdin, cmdStdout, processStdout, false));
+    } else {
+      promises.push(
+        Promise.resolve()
+          .then(() => cmd.execute({
+            args: parsedParams.args,
+            rawArgs: parsedParams.rawArgs,
+            flags: parsedParams.flags,
+            stdin: cmdStdin,
+            stdout: cmdStdout,
+            stderr: processStdout
+          }))
+          .then(() => {
+            if (cmdStdout !== processStdout && typeof cmdStdout.end === 'function') {
+              cmdStdout.end();
+            }
+          })
+          .catch((err) => {
+            if (cmdStdout !== processStdout && typeof cmdStdout.end === 'function') {
+              cmdStdout.end();
+            }
+            throw err;
+          })
+      );
+    }
+  }
+
+  await Promise.all(promises);
+}
+
+module.exports = { executePipeline };

package/src/core/lexer.js

@@ -0,0 +1,61 @@
+// A simple lexer to split respecting double quotes, single quotes, and escapes
+function tokenize(input) {
+  const tokens = [];
+  let currentToken = '';
+  let inDoubleQuotes = false;
+  let inSingleQuotes = false;
+  let escapeNext = false;
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+
+    if (escapeNext) {
+      currentToken += char;
+      escapeNext = false;
+      continue;
+    }
+
+    if (char === '\\' && !inSingleQuotes) {
+      escapeNext = true;
+      continue;
+    }
+
+    if (char === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+      continue;
+    }
+
+    if (char === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+      continue;
+    }
+
+    if (char === ' ' || char === '\t') {
+      if (inSingleQuotes || inDoubleQuotes) {
+        currentToken += char;
+      } else if (currentToken.length > 0) {
+        tokens.push(currentToken);
+        currentToken = '';
+      }
+      continue;
+    }
+
+    if (char === '|' && !inSingleQuotes && !inDoubleQuotes) {
+      if (currentToken.length > 0) tokens.push(currentToken);
+      tokens.push('|');
+      currentToken = '';
+      continue;
+    }
+
+    // append char
+    currentToken += char;
+  }
+
+  if (currentToken.length > 0) {
+    tokens.push(currentToken);
+  }
+
+  return tokens;
+}
+
+module.exports = { tokenize };