main.cpp

// compile: g++ -std=c++17 -static -o linuxify.exe main.cpp registry.cpp -lpsapi -lws2_32 -liphlpapi -lwininet -lwlanapi 2>&1

#include <io.h>
#include <stdio.h>
#include <string>
#include <vector>
#include <sstream>
#include <filesystem>
#include <fstream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <aclapi.h>
#include <tlhelp32.h>
#include <psapi.h>
#include <conio.h>
#include <algorithm>
#include <iomanip>
#include <sstream>
#include <ctime>
#include <map>
#include <functional>
#include <sys/utime.h>
#include <regex>
#include <deque>
#include <thread>
#include <chrono>
#include <list>
#include <set>

#include "registry.hpp"
#include "process_manager.hpp"
#include "system_info.hpp"
#include "networking.hpp"
#include "cmds-src/interpreter.hpp"
#include "cmds-src/auto-suggest.hpp"
#include "cmds-src/auto-nav.hpp"
#include "cmds-src/arith.hpp"
#include "cmds-src/wsl_proxy/lxss_kernel.hpp"
#include "cmds-src/fuzzy.hpp"
#include "shell_api.hpp"
#include "interrupt.hpp"
#include "signal_handler.hpp"
#include "io_handler.hpp"
#include "input_handler.hpp"
#include "shell_streams.hpp"
#include "crash_handler.hpp"
#include "cmds-src/glob.hpp"
#include "cmds-src/child_handler.hpp"
#include "error_handling.hpp"
#include "link_handler.hpp"


// Global process manager instance
ProcessManager g_procMgr;

// IPC pipe name for crond communication
const char* CROND_PIPE_NAME = "\\\\.\\pipe\\LinuxifyCrond";

namespace fs = std::filesystem;

#include "engine/continuation.hpp"
#include "engine/shell_context.hpp"
#include "engine/states.hpp"
#include "engine/session_manager.hpp"

// Global session manager
SessionManager g_sessionManager;

class ShellLogic {
    friend void execute_command_logic(ShellContext& ctx, const std::string& input); // Allow access to private members
    private:
        ShellContext& ctx; 

    // Internal commands set
    const std::set<std::string> internalCmds = {
        "echo", "pwd", "cd", "type", "clear", "env", "export",
        "which", "history", "lin", "jobs", "fg", "bg", "uninstall",
        "setup", "alias", "unalias", "source", "read", "test", "true", "false",
        "exit", "help", "man", "fuzz", "registry"
    }; 


public:
    ShellLogic(ShellContext& context) : ctx(context) {
        // Check Admin Status
        {
            BOOL isAdmin = FALSE;
            PSID adminGroup = NULL;
            SID_IDENTIFIER_AUTHORITY ntAuthority = SECURITY_NT_AUTHORITY;
            if (AllocateAndInitializeSid(&ntAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID,
                DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &adminGroup)) {
                CheckTokenMembership(NULL, adminGroup, &isAdmin);
                FreeSid(adminGroup);
            }
            ctx.isAdmin = (isAdmin == TRUE);
            ctx.sessionEnv["IS_ADMIN"] = ctx.isAdmin ? "1" : "0";
        }

        {
            std::string builtinsList;
            for (const auto& cmd : internalCmds) {
                if (!builtinsList.empty()) builtinsList += ";";
                builtinsList += cmd;
            }
            _putenv_s("LINUXIFY_BUILTINS", builtinsList.c_str());
        }

        ctx.interpreter.bindVariables(ctx.sessionEnv);
        ctx.interpreter.bindArrays(&ctx.sessionArrayEnv);
        // Bind input handler for read command
        ctx.interpreter.bindInputHandler([](std::string prompt, bool isPassword) -> std::string {
            if (!_isatty(_fileno(stdin))) {
                 if (!prompt.empty()) {
                    std::cout << prompt;
                    std::cout.flush();
                 }
                 std::string line;
                 std::getline(std::cin, line);
                 return line;
            }
            return InputHandler::readSimpleLine(prompt, isPassword);
        });

        // Bind Alias Resolver
        ctx.interpreter.setAliasResolver([this](const std::string& cmd) -> std::string {
             if (ctx.aliasInContext.hasAlias(cmd)) {
                 return ctx.aliasInContext.getAlias(cmd);
             }
             return cmd;
        });

        // Register fallback handler for internal commands
        ctx.interpreter.getExecutor().setFallbackHandler([this](const std::vector<std::string>& args) -> int {
            if (args.empty()) return -1;
            if (isInternalCommand(args[0])) {
                this->executeCommand(args);
                return ctx.lastExitCode;
            }
            return -1;
        });
    }
    
    // Check if input contains shell syntax that requires the interpreter
    bool isShellSyntax(const std::string& input) {
        if (input.empty()) return false;
        
        std::string trimInput = input;
        trimInput.erase(0, trimInput.find_first_not_of(" \t"));
        std::string firstWord;
        size_t fwEnd = trimInput.find_first_of(" \t");
        if (fwEnd != std::string::npos) firstWord = trimInput.substr(0, fwEnd);
        else firstWord = trimInput;
        if (firstWord == "export") {
            std::string rest = (fwEnd != std::string::npos) ? trimInput.substr(fwEnd) : "";
            if (rest.find("-obj") != std::string::npos || rest.find("-arr") != std::string::npos) {
                return false;
            }
        }
        
        static const std::vector<std::string> syntaxKeywords = {
            "if", "for", "while", "case", "function", "declare", "typeset", "local",
            "read", "source", ".", "[[", "((", "select", "until", "elif", "fi", "done", "esac",
            "do", "then", "else", "{", "}"
        };
        
        size_t eqPos = input.find('=');
        if (eqPos != std::string::npos && eqPos > 0) {
            bool isAssignment = true;
            for (size_t i = 0; i < eqPos; i++) {
                if (!isalnum(input[i]) && input[i] != '_') {
                    isAssignment = false;
                    break;
                }
            }
            if (isAssignment) return true;
        }

        try {
            Bash::Lexer lexer(input);
            auto tokens = lexer.tokenize();
            
            bool isExportCmd = false;
            if (!tokens.empty() && tokens[0].type == Bash::TokenType::WORD && tokens[0].value == "export") {
                isExportCmd = true;
            }
            
            for (const auto& token : tokens) {
                switch (token.type) {
                    case Bash::TokenType::KW_IF:
                    case Bash::TokenType::KW_FOR:
                    case Bash::TokenType::KW_WHILE:
                    case Bash::TokenType::KW_CASE:
                    case Bash::TokenType::KW_FUNCTION:
                    case Bash::TokenType::LBRACE:
                    case Bash::TokenType::LPAREN:
                    case Bash::TokenType::SEMICOLON:
                        if (isExportCmd && (token.type == Bash::TokenType::LBRACE)) continue;
                        return true;
                    case Bash::TokenType::WORD:
                        // Check for specific command words that we want interpreter to handle
                        if (token.value == "declare" || token.value == "typeset" || 
                            token.value == "local" || token.value == "read" || 
                            token.value == "source" || token.value == ".") {
                            return true;
                        }
                        break;
                    default:
                        break;
                }
            }
        } catch (const Bash::ScriptError&) {
            return true;
        } catch (...) {
            return false;
        }
        
        return false;
    }

    // Check if a command is internal
    bool isInternalCommand(const std::string& cmd) {
        return internalCmds.count(cmd);
    }

    std::vector<std::string> tokenize(const std::string& input) {

        std::vector<std::string> tokens;
        std::string token;
        bool inQuotes = false;
        char quoteChar = '\0';

        for (size_t i = 0; i < input.length(); ++i) {
            char c = input[i];

            if ((c == '"' || c == '\'') && !inQuotes) {
                inQuotes = true;
                quoteChar = c;
            } else if (c == quoteChar && inQuotes) {
                inQuotes = false;
                quoteChar = '\0';
            } else if (c == ' ' && !inQuotes) {
                if (!token.empty()) {
                    tokens.push_back(token);
                    token.clear();
                }
            } else {
                token += c;
            }
        }

        if (!token.empty()) {
            tokens.push_back(token);
        }

        return tokens;
    }

    void printError(const std::string& message) {
        LOG_ERROR(message);
    }

    void printSuccess(const std::string& message) {
        ShellIO::sout << ShellIO::Color::LightGreen << message 
                      << ShellIO::Color::Reset << ShellIO::endl;
    }

    // Execute a command - handles built-in commands internally or uses CreateProcessA for external
    // Returns exit code, -1 on failure
    int runProcess(const std::string& originalCmdLine, const std::string& workDir = "", bool wait = true) {
        // Resolve aliases
        std::string cmdLine = ctx.aliasInContext.resolve(originalCmdLine);
        
        // First, tokenize and check if it's a built-in command
        std::vector<std::string> tokens;
        std::istringstream iss(cmdLine);
        std::string token;
        bool inQuotes = false;
        std::string current;
        
        for (char c : cmdLine) {
            if (c == '"') {
                inQuotes = !inQuotes;
            } else if ((c == ' ' || c == '\t') && !inQuotes) {
                if (!current.empty()) {
                    tokens.push_back(current);
                    current.clear();
                }
            } else {
                current += c;
            }
        }
        if (!current.empty()) tokens.push_back(current);
        
        if (tokens.empty()) return 0;
        
        std::string cmd = tokens[0];
        


        {
            fs::path cmdPath(cmd);
            std::string ext = cmdPath.extension().string();
            std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
            
            if (ext == ".ps1") {
                fs::path scriptPath;
                if (cmdPath.is_absolute()) {
                    scriptPath = cmdPath;
                } else {
                    scriptPath = fs::path(ctx.currentDir) / cmdPath;
                }
                try {
                    if (fs::exists(scriptPath)) {
                        scriptPath = fs::canonical(scriptPath);
                        std::string psCmd = "powershell.exe -ExecutionPolicy Bypass -File \"" + scriptPath.string() + "\"";
                        for (size_t i = 1; i < tokens.size(); i++) {
                            psCmd += " \"" + tokens[i] + "\"";
                        }
                        const std::string dir = workDir.empty() ? ctx.currentDir : workDir;
                        return ChildHandler::spawn(psCmd, dir, wait);
                    }
                } catch (...) {}
            }
            
            if (ext == ".bat" || ext == ".cmd") {
                fs::path scriptPath;
                if (cmdPath.is_absolute()) {
                    scriptPath = cmdPath;
                } else {
                    scriptPath = fs::path(ctx.currentDir) / cmdPath;
                }
                try {
                    if (fs::exists(scriptPath)) {
                        scriptPath = fs::canonical(scriptPath);
                        std::string batCmd = "cmd.exe /c \"\"" + scriptPath.string() + "\"";
                        for (size_t i = 1; i < tokens.size(); i++) {
                            batCmd += " \"" + tokens[i] + "\"";
                        }
                        batCmd += "\"";
                        const std::string dir = workDir.empty() ? ctx.currentDir : workDir;
                        return ChildHandler::spawn(batCmd, dir, wait);
                    }
                } catch (...) {}
            }
        }

        if (internalCmds.count(cmd)) {
            std::string output = ctx.interpreter.getExecutor().executeAndCapture(cmdLine);
            std::cout << output;
            if (!output.empty() && output.back() != '\n') std::cout << "\n";
            return ctx.lastExitCode; 
        }
        
        const std::string dir = workDir.empty() ? ctx.currentDir : workDir;
        return ChildHandler::spawn(cmdLine, dir, wait);
    }
    
    // Execute a pipeline of commands using real Windows pipes
    // Returns exit code of last command
    int executePipeline(const std::vector<std::string>& commands, HANDLE hRedirectOut = INVALID_HANDLE_VALUE) {
        if (commands.empty()) return 0;
        if (commands.size() == 1 && hRedirectOut == INVALID_HANDLE_VALUE) {
            return runProcess(commands[0]);
        }
        
        // For pipelines, we need to chain processes with real pipes
        std::vector<HANDLE> processes;
        std::vector<HANDLE> threads;
        HANDLE hPrevReadPipe = NULL;

        // Restore console mode for the pipeline
        SignalHandler::InputDispatcher::getInstance().restore();
        
        for (size_t i = 0; i < commands.size(); i++) {
            SECURITY_ATTRIBUTES saAttr;
            saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
            saAttr.bInheritHandle = TRUE;
            saAttr.lpSecurityDescriptor = NULL;
            
            HANDLE hReadPipe = NULL, hWritePipe = NULL;
            
            // Create pipe for output (except for last command)
            if (i < commands.size() - 1) {
                if (!CreatePipe(&hReadPipe, &hWritePipe, &saAttr, 0)) {
                    SignalHandler::InputDispatcher::getInstance().init();
                    return -1;
                }
            }
            // For the last command, if we have a redirection handle, use it
            else if (hRedirectOut != INVALID_HANDLE_VALUE) {
                 hWritePipe = hRedirectOut;
                 // Don't close hRedirectOut in the loop!
            }
            
            // Tokenize command to find executable
            std::vector<std::string> tokens = tokenize(commands[i]);
            if (tokens.empty()) continue;
            
            std::string cmd = tokens[0];
            std::string cmdLine;
            
            if (internalCmds.count(cmd)) {
                 // Internal command: spawn self with -c
                 char selfPath[MAX_PATH];
                 GetModuleFileNameA(NULL, selfPath, MAX_PATH);
                 
                 // Escape quotes
                 std::string escapedCmd;
                 for (char c : commands[i]) {
                     if (c == '"') escapedCmd += "\\\"";
                     else escapedCmd += c;
                 }
                 
                 cmdLine = "\"" + std::string(selfPath) + "\" -c \"" + escapedCmd + "\"";
            } else {
                std::string execPath;
                char exePath[MAX_PATH];
                GetModuleFileNameA(NULL, exePath, MAX_PATH);
                fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
                std::vector<std::string> exts = {".exe", ".cmd", ".bat", ""};
                for (const auto& ext : exts) {
                    fs::path tryPath = cmdsDir / (cmd + ext);
                    if (fs::exists(tryPath)) { execPath = tryPath.string(); break; }
                }
                if (execPath.empty()) {
                    std::string regPath = g_registry.getExecutablePath(cmd);
                    if (!regPath.empty() && fs::exists(regPath)) execPath = regPath;
                }
                if (execPath.empty()) {
                    std::string resolved = resolvePath(cmd);
                    if (fs::exists(resolved)) execPath = resolved;
                }
                if (execPath.empty() && (cmd.find('/') != std::string::npos || cmd.find('\\') != std::string::npos)) {
                    execPath = cmd;
                }
                if (execPath.empty()) execPath = cmd;
                
                cmdLine = "\"" + execPath + "\"";
                for (size_t j = 1; j < tokens.size(); j++) {
                    cmdLine += " \"" + tokens[j] + "\"";
                }
            }
            
            // Setup process
            STARTUPINFOA si;
            PROCESS_INFORMATION pi;
            ZeroMemory(&si, sizeof(si));
            si.cb = sizeof(si);
            si.dwFlags = STARTF_USESTDHANDLES;
            
            si.hStdInput = (hPrevReadPipe) ? hPrevReadPipe : GetStdHandle(STD_INPUT_HANDLE);
            si.hStdOutput = (hWritePipe) ? hWritePipe : GetStdHandle(STD_OUTPUT_HANDLE);
            si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
            
            ZeroMemory(&pi, sizeof(pi));
            
            std::vector<char> cmdBuffer(cmdLine.length() + 1);
            strcpy(cmdBuffer.data(), cmdLine.c_str());
            
            if (CreateProcessA(NULL, cmdBuffer.data(), NULL, NULL, TRUE, 0, NULL,
                               ctx.currentDir.c_str(), &si, &pi)) {
                processes.push_back(pi.hProcess);
                threads.push_back(pi.hThread);
            }
            
            if (hWritePipe && hWritePipe != hRedirectOut) CloseHandle(hWritePipe);
            if (hPrevReadPipe) CloseHandle(hPrevReadPipe);
            hPrevReadPipe = hReadPipe;
        }
        
        // Wait for all processes
        int exitCode = 0;
        for (size_t i = 0; i < processes.size(); i++) {
            WaitForSingleObject(processes[i], INFINITE);
            if (i == processes.size() - 1) {
                DWORD code;
                GetExitCodeProcess(processes[i], &code);
                exitCode = (int)code;
            }
            CloseHandle(processes[i]);
            CloseHandle(threads[i]);
        }

        // Restore raw mode
        SignalHandler::InputDispatcher::getInstance().init();
        
        return exitCode;
    }
    

    


    std::string resolvePath(const std::string& path) {
        if (path.empty()) {
            return ctx.currentDir;
        }
        
        fs::path p(path);
        if (p.is_absolute()) {
            return fs::canonical(p).string();
        }
        
        fs::path fullPath = fs::path(ctx.currentDir) / path;
        try {
            return fs::canonical(fullPath).string();
        } catch (...) {
            return fullPath.string();
        }
    }

    void cmdPwd(const std::vector<std::string>& args) {
        std::cout << ctx.currentDir << std::endl;
    }

    void cmdCd(const std::vector<std::string>& args) {
        std::string targetDir;
        
        if (args.size() < 2) {
            char* homeDir = getenv("USERPROFILE");
            if (homeDir) {
                targetDir = homeDir;
            } else {
                printError("Could not find home directory");
                return;
            }
        } else if (args[1] == "-") {
            LOG_WARNING("Previous directory tracking not implemented yet");
            return;
        } else if (args[1] == "..") {
            fs::path parent = fs::path(ctx.currentDir).parent_path();
            targetDir = parent.string();
        } else if (args[1] == "~") {
            char* homeDir = getenv("USERPROFILE");
            if (homeDir) {
                targetDir = homeDir;
            } else {
                printError("Could not find home directory");
                return;
            }
        } else if (args[1] == "...") {
            LOG_ERROR("cd: ...: No such file or directory");
            return;
        } else {
            targetDir = resolvePath(args[1]);
        }

        try {
            if (fs::exists(targetDir) && fs::is_directory(targetDir)) {
                ctx.currentDir = fs::canonical(targetDir).string();
            } else {
                LOG_ERROR("cd: " + args[1] + ": No such directory");
            }
        } catch (const std::exception& e) {
            LOG_ERROR("cd: " + std::string(e.what()));
        }
    }

    void cmdLs(const std::vector<std::string>& args) {
        bool showAll = false;
        bool longFormat = false;
        bool recursive = false;
        bool humanReadable = false;
        bool reverse = false;
        bool timeSort = false;
        bool sizeSort = false;
        bool color = true;
        bool oneColumn = false;
        std::vector<std::string> paths;

        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-a" || arg == "--all") showAll = true;
            else if (arg == "-l") longFormat = true;
            else if (arg == "-R" || arg == "--recursive") recursive = true;
            else if (arg == "-h" || arg == "--human-readable") humanReadable = true;
            else if (arg == "-r" || arg == "--reverse") reverse = true;
            else if (arg == "-t") timeSort = true;
            else if (arg == "-S") sizeSort = true;
            else if (arg == "-1") oneColumn = true;
            else if (arg == "--color=never") color = false;
            else if (arg == "--color=auto" || arg == "--color=always") color = true;
            else if (arg.length() > 1 && arg[0] == '-') {
                for (size_t k = 1; k < arg.length(); ++k) {
                    if (arg[k] == 'a') showAll = true;
                    else if (arg[k] == 'l') longFormat = true;
                    else if (arg[k] == 'R') recursive = true;
                    else if (arg[k] == 'h') humanReadable = true;
                    else if (arg[k] == 'r') reverse = true;
                    else if (arg[k] == 't') timeSort = true;
                    else if (arg[k] == 'S') sizeSort = true;
                    else if (arg[k] == '1') oneColumn = true;
                }
            }
            else paths.push_back(arg);
        }

        if (paths.empty()) paths.push_back(ctx.currentDir);

        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        CONSOLE_SCREEN_BUFFER_INFO csbi;
        GetConsoleScreenBufferInfo(hConsole, &csbi);
        int termWidth = csbi.dwSize.X;
        if (termWidth <= 0) termWidth = 80;

        auto formatSize = [&](uintmax_t size) -> std::string {
            if (!humanReadable) return std::to_string(size);
            const char* units[] = {"B", "K", "M", "G", "T"};
            int unit = 0;
            double s = static_cast<double>(size);
            while (s >= 1024 && unit < 4) {
                s /= 1024;
                unit++;
            }
            std::stringstream ss;
            ss << std::fixed << std::setprecision(1) << s << units[unit];
            return ss.str();
        };

        auto printEntryLong = [&](const fs::directory_entry& entry) {
             std::string perms;
             if (fs::is_directory(entry)) perms = "d";
             else if (fs::is_symlink(entry)) perms = "l";
             else perms = "-";
             
             try {
                 auto status = fs::status(entry);
                 auto p = status.permissions();
                 perms += (p & fs::perms::owner_read) != fs::perms::none ? "r" : "-";
                 perms += (p & fs::perms::owner_write) != fs::perms::none ? "w" : "-";
                 perms += (p & fs::perms::owner_exec) != fs::perms::none ? "x" : "-";
                 perms += (p & fs::perms::group_read) != fs::perms::none ? "r" : "-";
                 perms += (p & fs::perms::group_write) != fs::perms::none ? "w" : "-";
                 perms += (p & fs::perms::group_exec) != fs::perms::none ? "x" : "-";
                 perms += (p & fs::perms::others_read) != fs::perms::none ? "r" : "-";
                 perms += (p & fs::perms::others_write) != fs::perms::none ? "w" : "-";
                 perms += (p & fs::perms::others_exec) != fs::perms::none ? "x" : "-";
             } catch(...) { perms += "---------"; }

             uintmax_t size = 0;
             if (!fs::is_directory(entry)) {
                 try { size = fs::file_size(entry); } catch(...) {}
             }
             
             char timeBuf[64] = "Unknown";
             try {
                 auto ftime = fs::last_write_time(entry);
                 auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                     ftime - fs::file_time_type::clock::now() + std::chrono::system_clock::now());
                 std::time_t cftime = std::chrono::system_clock::to_time_t(sctp);
                 std::tm* tm = std::localtime(&cftime);
                 if (tm) std::strftime(timeBuf, sizeof(timeBuf), "%b %d %H:%M", tm);
             } catch(...) {}

             std::cout << perms << " " << std::setw(humanReadable ? 6 : 10) << formatSize(size) << " " << timeBuf << " ";

             if (color) {
                 if (fs::is_directory(entry)) SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                 else if (fs::is_symlink(entry)) SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                 else {
                     std::string ext = entry.path().extension().string();
                     std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
                     if (ext == ".exe" || ext == ".bat" || ext == ".cmd" || ext == ".sh") 
                         SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                     else if (ext == ".zip" || ext == ".tar" || ext == ".gz")
                         SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
                     else if (ext == ".jpg" || ext == ".png" || ext == ".bmp")
                         SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                 }
             }
             
             std::cout << entry.path().filename().string();
             if (color) SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
             std::cout << std::endl;
        };

        auto printEntriesColumnar = [&](const std::vector<fs::directory_entry>& entries) {
            if (entries.empty()) return;

            size_t maxLen = 0;
            for (const auto& entry : entries) {
                size_t len = entry.path().filename().string().length();
                if (len > maxLen) maxLen = len;
            }
            
            int colWidth = (int)maxLen + 2;
            if (colWidth < 1) colWidth = 1;
            int numCols = termWidth / colWidth;
            if (numCols < 1) numCols = 1;

            int col = 0;
            for (const auto& entry : entries) {
                std::string name = entry.path().filename().string();
                
                if (color) {
                    if (fs::is_directory(entry)) SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    else if (fs::is_symlink(entry)) SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    else {
                        std::string ext = entry.path().extension().string();
                        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
                        if (ext == ".exe" || ext == ".bat" || ext == ".cmd" || ext == ".sh") 
                            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                        else if (ext == ".zip" || ext == ".tar" || ext == ".gz")
                            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
                        else if (ext == ".jpg" || ext == ".png" || ext == ".bmp")
                            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                        else
                            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                    }
                }
                
                std::cout << name;
                if (color) SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                
                col++;
                if (col >= numCols) {
                    std::cout << std::endl;
                    col = 0;
                } else {
                    int padding = colWidth - (int)name.length();
                    for (int i = 0; i < padding; i++) std::cout << ' ';
                }
            }
            if (col != 0) std::cout << std::endl;
        };

        auto listDir = [&](auto&& self, const std::string& p) -> void {
             if (!fs::exists(p)) {
                 LOG_ERROR("ls: cannot access '" + p + "': No such file or directory");
                 return;
             }
             if (!fs::is_directory(p)) {
                 fs::directory_entry entry(p);
                 if (longFormat) {
                     printEntryLong(entry);
                 } else {
                     std::vector<fs::directory_entry> single = {entry};
                     printEntriesColumnar(single);
                 }
                 return;
             }
             
             if (recursive && paths.size() > 1) std::cout << p << ":" << std::endl;
             
             std::vector<fs::directory_entry> entries;
             try {
                 for (const auto& entry : fs::directory_iterator(p)) {
                     std::string name = entry.path().filename().string();
                     if (!showAll && name[0] == '.') continue;
                     entries.push_back(entry);
                 }
             } catch (const std::exception& e) {
                 LOG_ERROR("ls: " + std::string(e.what()));
                 return;
             }
             
             std::sort(entries.begin(), entries.end(), [&](const fs::directory_entry& a, const fs::directory_entry& b) {
                 if (timeSort) return fs::last_write_time(a) > fs::last_write_time(b);
                 if (sizeSort) {
                     uintmax_t sa = 0, sb = 0;
                     if (!fs::is_directory(a)) sa = fs::file_size(a);
                     if (!fs::is_directory(b)) sb = fs::file_size(b);
                     return sa > sb;
                 }
                 return a.path().filename().string() < b.path().filename().string();
             });
             
             if (reverse) std::reverse(entries.begin(), entries.end());
             
             if (longFormat) {
                 for (const auto& entry : entries) {
                     printEntryLong(entry);
                 }
             } else if (oneColumn) {
                 for (const auto& entry : entries) {
                     if (color) {
                         if (fs::is_directory(entry)) SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                         else if (fs::is_symlink(entry)) SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                         else {
                             std::string ext = entry.path().extension().string();
                             std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
                             if (ext == ".exe" || ext == ".bat" || ext == ".cmd" || ext == ".sh") 
                                 SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                             else if (ext == ".zip" || ext == ".tar" || ext == ".gz")
                                 SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
                             else if (ext == ".jpg" || ext == ".png" || ext == ".bmp")
                                 SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                             else
                                 SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                         }
                     }
                     std::cout << entry.path().filename().string();
                     if (color) SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                     std::cout << std::endl;
                 }
             } else {
                 printEntriesColumnar(entries);
             }
             
             if (recursive) {
                 for (const auto& entry : entries) {
                     if (fs::is_directory(entry)) {
                         std::string name = entry.path().filename().string();
                         if (name != "." && name != "..") {
                             std::cout << std::endl << entry.path().string() << ":" << std::endl;
                             self(self, entry.path().string());
                         }
                     }
                 }
             }
        };

        for (const auto& path : paths) {
             listDir(listDir, resolvePath(path));
        }
    }

    void cmdMkdir(const std::vector<std::string>& args) {
        bool parents = false;
        bool verbose = false;
        std::vector<std::string> dirs;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-p" || args[i] == "--parents") parents = true;
            else if (args[i] == "-v" || args[i] == "--verbose") verbose = true;
            else if (args[i][0] != '-') dirs.push_back(args[i]);
        }
        
        
        if (dirs.empty()) {
            LOG_ERROR("mkdir: missing operand");
            return;
        }

        for (const auto& dir : dirs) {
            try {
                std::string fullPath = resolvePath(dir);
                bool created = false;
                if (parents) created = fs::create_directories(fullPath);
                else created = fs::create_directory(fullPath);
                
                if (verbose && created) std::cout << "mkdir: created directory '" << dir << "'" << std::endl;
            } catch (const std::exception& e) {
                printError("mkdir: cannot create directory '" + dir + "': " + e.what());
            }
        }
    }

    void cmdRm(const std::vector<std::string>& args) {
        bool recursive = false;
        bool force = false; 
        bool interactive = false; 
        bool verbose = false; 
        std::vector<std::string> targets;

        for (size_t i = 1; i < args.size(); ++i) {
             std::string arg = args[i];
             if (arg == "-r" || arg == "-R" || arg == "--recursive") recursive = true;
             else if (arg == "-f" || arg == "--force") force = true;
             else if (arg == "-i" || arg == "--interactive") interactive = true;
             else if (arg == "-v" || arg == "--verbose") verbose = true;
             else if (arg.length() > 1 && arg[0] == '-') {
                  for (size_t k = 1; k < arg.length(); ++k) {
                       if (arg[k] == 'r' || arg[k] == 'R') recursive = true;
                       else if (arg[k] == 'f') force = true;
                       else if (arg[k] == 'i') interactive = true;
                       else if (arg[k] == 'v') verbose = true;
                  }
             }
             else targets.push_back(args[i]);
        }
        
        if (targets.empty()) {
             LOG_ERROR("rm: missing operand");
             return;
        }

        for (const auto& target : targets) {
             std::string fullPath = resolvePath(target);
             if (!fs::exists(fullPath)) {
                 if (!force) LOG_ERROR("rm: cannot remove '" + target + "': No such file or directory");
                 continue;
             }
             
             if (interactive) {
                 std::string prompt = "rm: remove " + std::string(fs::is_directory(fullPath) ? "directory" : "regular file") + " '" + target + "'? ";
                 if (!ShellAPI::confirm(prompt)) continue;
             }

             try {
                 if (fs::is_directory(fullPath)) {
                     if (!recursive) {
                         LOG_ERROR("rm: cannot remove '" + target + "': Is a directory");
                         continue;
                     }
                     fs::remove_all(fullPath);
                     if (verbose) std::cout << "removed directory '" << target << "'" << std::endl;
                 } else {
                     fs::remove(fullPath);
                     if (verbose) std::cout << "removed '" << target << "'" << std::endl;
                 }
             } catch (const fs::filesystem_error& e) {
                 // Even with force, we report failures to remove EXISTING files (e.g. Permission Denied)
                 // e.code().value() on Windows matches GetLastError()
                 ErrorHandling::log(ErrorHandling::Level::Error, "rm: cannot remove '" + target + "'", __FILE__, __LINE__, e.code().value());
             } catch (const std::exception& e) {
                 LOG_ERROR("rm: cannot remove '" + target + "': " + std::string(e.what()));
             }
        }
    }

    void cmdMv(const std::vector<std::string>& args) {
         bool interactive = false;
         bool noClobber = false; 
         bool update = false;
         bool verbose = false;
         std::vector<std::string> operands;
         
         for (size_t i = 1; i < args.size(); ++i) {
             std::string arg = args[i];
             if (arg == "-i" || arg == "--interactive") interactive = true;
             else if (arg == "-n" || arg == "--no-clobber") noClobber = true;
             else if (arg == "-u" || arg == "--update") update = true;
             else if (arg == "-v" || arg == "--verbose") verbose = true;
             else if (arg[0] != '-') operands.push_back(arg);
         }
         
         if (operands.size() < 2) {
             printError("mv: missing operand");
             return;
         }
         
         std::string destPath = resolvePath(operands.back());
         bool destIsDir = fs::exists(destPath) && fs::is_directory(destPath);
         
         if (operands.size() > 2 && !destIsDir) {
              printError("mv: target '" + operands.back() + "' is not a directory");
              return;
         }
         
         for (size_t i = 0; i < operands.size() - 1; ++i) {
              std::string sourcePath = resolvePath(operands[i]);
              if (!fs::exists(sourcePath)) {
                  printError("mv: cannot stat '" + operands[i] + "': No such file or directory");
                  continue;
              }
              
              std::string actualDest = destPath;
              if (destIsDir) {
                  actualDest = (fs::path(destPath) / fs::path(sourcePath).filename()).string();
              }
              
              if (fs::exists(actualDest)) {
                   if (noClobber) continue;
                   if (update) {
                       try {
                           if (fs::last_write_time(sourcePath) <= fs::last_write_time(actualDest)) continue;
                       } catch(...) {}
                   }
                   if (interactive) {
                       std::string prompt = "mv: overwrite '" + actualDest + "'? ";
                       if (!ShellAPI::confirm(prompt)) continue;
                   }
                   fs::remove_all(actualDest); 
              }
              
              try {
                  fs::rename(sourcePath, actualDest);
                  if (verbose) std::cout << "renamed '" << operands[i] << "' -> '" << actualDest << "'" << std::endl;
              } catch (const std::exception& e) {
                  printError("mv: cannot move '" + operands[i] + "' to '" + actualDest + "': " + e.what());
              }
         }
    }

    void cmdCp(const std::vector<std::string>& args) {
         bool recursive = false;
         bool interactive = false;
         bool noClobber = false;
         bool update = false;
         bool verbose = false;
         std::vector<std::string> operands;
         
         for (size_t i = 1; i < args.size(); ++i) {
             std::string arg = args[i];
             if (arg == "-r" || arg == "-R" || arg == "--recursive") recursive = true;
             else if (arg == "-i" || arg == "--interactive") interactive = true;
             else if (arg == "-n" || arg == "--no-clobber") noClobber = true;
             else if (arg == "-u" || arg == "--update") update = true;
             else if (arg == "-v" || arg == "--verbose") verbose = true;
             else if (arg.length() > 1 && arg[0] == '-') {
                  for (size_t k = 1; k < arg.length(); ++k) {
                       if (arg[k] == 'r' || arg[k] == 'R') recursive = true;
                       else if (arg[k] == 'i') interactive = true;
                       else if (arg[k] == 'n') noClobber = true;
                       else if (arg[k] == 'u') update = true;
                       else if (arg[k] == 'v') verbose = true;
                  }
             }
             else operands.push_back(arg);
         }
         
         if (operands.size() < 2) {
             printError("cp: missing operand");
             return;
         }
         
         std::string destPath = resolvePath(operands.back());
         bool destIsDir = fs::exists(destPath) && fs::is_directory(destPath);
         
         if (operands.size() > 2 && !destIsDir) {
              printError("cp: target '" + operands.back() + "' is not a directory");
              return;
         }
         
         for (size_t i = 0; i < operands.size() - 1; ++i) {
              std::string sourcePath = resolvePath(operands[i]);
              if (!fs::exists(sourcePath)) {
                   printError("cp: cannot stat '" + operands[i] + "': No such file or directory");
                   continue;
              }
              
              if (fs::is_directory(sourcePath) && !recursive) {
                   printError("cp: -r not specified; omitting directory '" + operands[i] + "'");
                   continue;
              }
              
              std::string actualDest = destPath;
              if (destIsDir) {
                   actualDest = (fs::path(destPath) / fs::path(sourcePath).filename()).string();
              }
              
              if (fs::exists(actualDest)) {
                   if (noClobber) continue;
                   if (update) {
                        try {
                             if (fs::last_write_time(sourcePath) <= fs::last_write_time(actualDest)) continue;
                        } catch(...) {}
                   }
                   if (interactive) {
                        std::cout << "cp: overwrite '" << actualDest << "'? ";
                        std::string ans;
                        std::getline(std::cin, ans);
                        if (ans.empty() || (ans[0] != 'y' && ans[0] != 'Y')) continue;
                   }
              }
              
              try {
                   auto options = fs::copy_options::overwrite_existing;
                   if (recursive) options |= fs::copy_options::recursive;
                   
                   if (fs::is_directory(sourcePath)) {
                       fs::copy(sourcePath, actualDest, options);
                   } else {
                       fs::copy_file(sourcePath, actualDest, options);
                   }
                   if (verbose) std::cout << "'" << operands[i] << "' -> '" << actualDest << "'" << std::endl;
              } catch (const std::exception& e) {
                   printError("cp: cannot copy: " + std::string(e.what()));
              }
         }
    }


    void cmdClear(const std::vector<std::string>& args) {
        IO::get().clearScreen();
    }

    // touch - create files or update timestamps
    void cmdTouch(const std::vector<std::string>& args) {
        bool noCreate = false;
        bool updateAccess = false;
        bool updateMod = false;
        std::string refFile;
        std::string dateStr;
        std::vector<std::string> files;

        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-c" || arg == "--no-create") noCreate = true;
            else if (arg == "-a") updateAccess = true;
            else if (arg == "-m") updateMod = true;
            else if (arg == "-r" && i + 1 < args.size()) refFile = args[++i];
            else if (arg == "-t" && i + 1 < args.size()) dateStr = args[++i];
            else if (arg[0] != '-') files.push_back(arg);
        }

        if (!updateAccess && !updateMod) {
            updateAccess = updateMod = true;
        }

        if (files.empty()) {
            printError("touch: missing file operand");
            return;
        }

        FILETIME ft = {0, 0};
        SYSTEMTIME st = {0};
        GetSystemTime(&st);
        
        if (!dateStr.empty()) {
            int year = st.wYear;
            int month = st.wMonth;
            int day = st.wDay;
            int hour = st.wHour;
            int min = st.wMinute;
            int sec = 0;
            
            size_t dotPos = dateStr.find('.');
            if (dotPos != std::string::npos) {
                if (dotPos + 1 < dateStr.length()) {
                    try { sec = std::stoi(dateStr.substr(dotPos + 1)); } catch(...) {}
                }
                dateStr = dateStr.substr(0, dotPos);
            }
            
            bool valid = true;
            try {
                if (dateStr.length() == 8) {
                    month = std::stoi(dateStr.substr(0, 2));
                    day = std::stoi(dateStr.substr(2, 2));
                    hour = std::stoi(dateStr.substr(4, 2));
                    min = std::stoi(dateStr.substr(6, 2));
                } else if (dateStr.length() == 10) {
                    int yy = std::stoi(dateStr.substr(0, 2));
                    year = (yy < 69) ? (2000 + yy) : (1900 + yy); 
                    month = std::stoi(dateStr.substr(2, 2));
                    day = std::stoi(dateStr.substr(4, 2));
                    hour = std::stoi(dateStr.substr(6, 2));
                    min = std::stoi(dateStr.substr(8, 2));
                } else if (dateStr.length() == 12) {
                    year = std::stoi(dateStr.substr(0, 4));
                    month = std::stoi(dateStr.substr(4, 2));
                    day = std::stoi(dateStr.substr(6, 2));
                    hour = std::stoi(dateStr.substr(8, 2));
                    min = std::stoi(dateStr.substr(10, 2));
                } else {
                    valid = false;
                }
            } catch(...) { valid = false; }
            
            if (valid) {
                st.wYear = year;
                st.wMonth = month;
                st.wDay = day;
                st.wHour = hour;
                st.wMinute = min;
                st.wSecond = sec;
                st.wMilliseconds = 0;
                SystemTimeToFileTime(&st, &ft);
            } else {
                printError("touch: invalid date format '" + dateStr + "'");
                return;
            }
        } else if (!refFile.empty()) {
            HANDLE hRef = CreateFileA(resolvePath(refFile).c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hRef != INVALID_HANDLE_VALUE) {
                GetFileTime(hRef, NULL, NULL, &ft);
                CloseHandle(hRef);
            } else {
                printError("touch: failed to get attributes of '" + refFile + "'");
                return;
            }
        } else {
            SystemTimeToFileTime(&st, &ft);
        }

        for (const auto& file : files) {
            std::string fullPath = resolvePath(file);
            
            if (!fs::exists(fullPath)) {
                if (noCreate) continue;
                HANDLE h = CreateFileA(fullPath.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
                if (h != INVALID_HANDLE_VALUE) {
                    CloseHandle(h);
                } else {
                    printError("touch: cannot touch '" + file + "': " + std::to_string(GetLastError()));
                    continue;
                }
            }

            HANDLE hFile = CreateFileA(fullPath.c_str(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
            if (hFile != INVALID_HANDLE_VALUE) {
                FILETIME* pAccess = updateAccess ? &ft : NULL;
                FILETIME* pWrite = updateMod ? &ft : NULL;
                if (!SetFileTime(hFile, NULL, pAccess, pWrite)) {
                     printError("touch: setting times of '" + file + "': " + std::to_string(GetLastError()));
                }
                CloseHandle(hFile);
            } else {
                printError("touch: cannot touch '" + file + "'");
            }
        }
    }

    void cmdChmod(const std::vector<std::string>& args) {
        if (args.size() < 3) {
            printError("chmod: missing operand");
            std::cout << "Usage: chmod [-R] <mode> <file>..." << std::endl;
            return;
        }

        bool recursive = false;
        bool verbose = false;
        std::string mode;
        std::vector<std::string> files;
        
        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-R" || arg == "--recursive") recursive = true;
            else if (arg == "-v" || arg == "--verbose") verbose = true;
            else if (mode.empty() && arg[0] != '-') mode = arg;
            else if (arg[0] != '-') files.push_back(arg);
        }

        if (mode.empty() || files.empty()) {
             printError("chmod: missing mode or file operand");
             return;
        }

        auto applyMode = [&](const std::string& path) {
             DWORD attrs = GetFileAttributesA(path.c_str());
             if (attrs == INVALID_FILE_ATTRIBUTES) return;
             
             DWORD newAttrs = attrs;
             
             if (isdigit(mode[0])) {
                 int m = mode[0] - '0';
                 if ((m & 2) == 0) newAttrs |= FILE_ATTRIBUTE_READONLY;
                 else newAttrs &= ~FILE_ATTRIBUTE_READONLY;
             } else {
                 bool add = false;
                 bool remove = false;
                 
                 for (char c : mode) {
                     if (c == '+') { add = true; remove = false; }
                     else if (c == '-') { add = false; remove = true; }
                     else if (c == 'w') {
                         if (add) newAttrs &= ~FILE_ATTRIBUTE_READONLY;
                         if (remove) newAttrs |= FILE_ATTRIBUTE_READONLY;
                     }
                     else if (c == 'h') {
                         if (add) newAttrs |= FILE_ATTRIBUTE_HIDDEN;
                         if (remove) newAttrs &= ~FILE_ATTRIBUTE_HIDDEN;
                     }
                 }
             }
             
             if (newAttrs != attrs) {
                 if (SetFileAttributesA(path.c_str(), newAttrs)) {
                     if (verbose) std::cout << "mode of '" << path << "' changed" << std::endl;
                 } else {
                     printError("chmod: changing permissions of '" + path + "': failed");
                 }
             }
        };

        for (const auto& file : files) {
             std::string root = resolvePath(file);
             if (!fs::exists(root)) {
                 printError("chmod: cannot access '" + file + "': No such file or directory");
                 continue;
             }
             
             applyMode(root);
             
             if (recursive && fs::is_directory(root)) {
                 try {
                     for (const auto& entry : fs::recursive_directory_iterator(root)) {
                         applyMode(entry.path().string());
                     }
                 } catch(...) {}
             }
        }
    }

    void cmdChown(const std::vector<std::string>& args) {
        if (args.size() < 3) {
            printError("chown: missing operand");
            std::cout << "Usage: chown [-R] <owner> <file>..." << std::endl;
            return;
        }

        bool recursive = false;
        bool verbose = false;
        std::string owner;
        std::vector<std::string> files;

        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-R" || arg == "--recursive") recursive = true;
            else if (arg == "-v" || arg == "--verbose") verbose = true;
            else if (owner.empty() && arg[0] != '-') owner = arg;
            else if (arg[0] != '-') files.push_back(arg);
        }

        if (owner.empty() || files.empty()) {
             printError("chown: missing owner or file operand");
             return;
        }

        size_t colon = owner.find(':');
        if (colon != std::string::npos) {
            owner = owner.substr(0, colon);
        }

        for (const auto& file : files) {
             std::string root = resolvePath(file);
             if (!fs::exists(root)) {
                 printError("chown: cannot access '" + file + "': No such file or directory");
                 continue;
             }
             // Use native Windows Security API to change ownership
             PSID pSid = NULL;
             SID_NAME_USE sidType;
             DWORD sidSize = 0, domainSize = 0;
             char domain[256];
             
             // First call to get buffer sizes
             LookupAccountNameA(NULL, owner.c_str(), NULL, &sidSize, domain, &domainSize, &sidType);
             pSid = (PSID)LocalAlloc(LMEM_FIXED, sidSize);
             domainSize = sizeof(domain);
             
             bool success = false;
             if (LookupAccountNameA(NULL, owner.c_str(), pSid, &sidSize, domain, &domainSize, &sidType)) {
                 DWORD result = SetNamedSecurityInfoA(
                     (LPSTR)root.c_str(),
                     SE_FILE_OBJECT,
                     OWNER_SECURITY_INFORMATION,
                     pSid,
                     NULL, NULL, NULL
                 );
                 success = (result == ERROR_SUCCESS);
                 
                 // Handle recursive if needed
                 if (success && recursive && fs::is_directory(root)) {
                     for (const auto& entry : fs::recursive_directory_iterator(root)) {
                         SetNamedSecurityInfoA(
                             (LPSTR)entry.path().string().c_str(),
                             SE_FILE_OBJECT,
                             OWNER_SECURITY_INFORMATION,
                             pSid,
                             NULL, NULL, NULL
                         );
                     }
                 }
             }
             
             if (pSid) LocalFree(pSid);
             
             if (success) {
                 if (verbose) std::cout << "ownership of '" + file + "' retained as " + owner << std::endl;
             } else {
                 printError("chown: changing ownership of '" + file + "': Operation not permitted (or user invalid)");
             }
        }
    }

    void cmdAlias(const std::vector<std::string>& args) {
        if (args.size() == 1) {
            // List all aliases
            const auto& aliases = ctx.aliasInContext.getAllAliases();
            for (const auto& pair : aliases) {
                std::cout << "alias " << pair.first << "='" << pair.second << "'" << std::endl;
            }
            return;
        }

        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            size_t eqPos = arg.find('=');
            
            if (eqPos != std::string::npos) {
                std::string name = arg.substr(0, eqPos);
                std::string value = arg.substr(eqPos + 1);
                
                // If the value is quoted (e.g. alias foo="'bar'"), remove the outer quotes
                if (value.size() >= 2) {
                    char first = value.front();
                    char last = value.back();
                    if ((first == '"' && last == '"') || (first == '\'' && last == '\'')) {
                        value = value.substr(1, value.size() - 2);
                    }
                }
                
                ctx.aliasInContext.addAlias(name, value);
            } else {
                std::string val = ctx.aliasInContext.getAlias(arg);
                if (!val.empty()) {
                    std::cout << "alias " << arg << "='" << val << "'" << std::endl;
                } else {
                    printError("alias: " + arg + ": not found");
                }
            }
        }
    }

    void cmdUnalias(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("unalias: usage: unalias name [name ...]");
            return;
        }
        
        if (args[1] == "-a") {
             ctx.aliasInContext.clear();
             return;
        }

        for (size_t i = 1; i < args.size(); ++i) {
            ctx.aliasInContext.removeAlias(args[i]);
        }
    }

    // Get history file path
    std::string getLinuxdbPath() {
        const char* appdata = std::getenv("APPDATA");
        fs::path linuxdbDir;
        if (appdata) {
            linuxdbDir = fs::path(appdata) / "Linuxify" / "linuxdb";
        } else {
            char exePath[MAX_PATH];
            GetModuleFileNameA(NULL, exePath, MAX_PATH);
            linuxdbDir = fs::path(exePath).parent_path() / "linuxdb";
        }
        if (!fs::exists(linuxdbDir)) {
            fs::create_directories(linuxdbDir);
        }
        return linuxdbDir.string();
    }
    
    std::string getHistoryFilePath() {
        return (fs::path(getLinuxdbPath()) / "history.lin").string();
    }

    // Load history from file
    void loadHistory() {
        ctx.commandHistory.clear();
        std::ifstream file(getHistoryFilePath());
        if (file) {
            std::string line;
            while (std::getline(file, line)) {
                if (!line.empty()) {
                    ctx.commandHistory.push_back(line);
                }
            }
        }
    }

    // Save command to history
    void saveToHistory(const std::string& cmd) {
        ctx.commandHistory.push_back(cmd);
        
        std::string path = getHistoryFilePath();
        std::ofstream file(path, std::ios::app);
        
        if (!file) {
            // Robustness: If open failed, try re-creating the directory
            // This handles cases where the user deleted the linuxdb folder while shell was running
            fs::path p(path);
            try {
                fs::create_directories(p.parent_path());
                file.open(path, std::ios::app);
            } catch (...) {}
        }

        if (file) {
            file << cmd << "\n";
        }
    }

    std::string getVarFilePath() {
        return (fs::path(getLinuxdbPath()) / "var.lin").string();
    }

    void loadPersistentVars() {
        std::ifstream file(getVarFilePath());
        if (!file) return;
        
        std::string line;
        while (std::getline(file, line)) {
            if (line.empty() || line[0] == '#') continue;
            
            if (line.substr(0, 4) == "OBJ:") {
                std::string rest = line.substr(4);
                size_t braceStart = rest.find('{');
                if (braceStart == std::string::npos) continue;
                std::string objName = rest.substr(0, braceStart);
                size_t o_first = objName.find_first_not_of(" \t\r\n");
                if (o_first != std::string::npos) {
                    size_t o_last = objName.find_last_not_of(" \t\r\n");
                    objName = objName.substr(o_first, o_last - o_first + 1);
                } else {
                    objName = "";
                }
                if (objName.empty()) continue;
                
                size_t braceEnd = rest.find_last_of('}');
                if (braceEnd == std::string::npos || braceEnd <= braceStart) continue;
                std::string body = rest.substr(braceStart + 1, braceEnd - braceStart - 1);
                std::map<std::string, std::string> members;
                std::map<std::string, std::vector<std::string>> arrMembers;
                size_t p = 0;
                while (p < body.size()) {
                    size_t colonPos = body.find(':', p);
                    if (colonPos == std::string::npos) break;
                    std::string key = body.substr(p, colonPos - p);
                    size_t k_first = key.find_first_not_of(" \t\r\n");
                    if (k_first != std::string::npos) {
                        size_t k_last = key.find_last_not_of(" \t\r\n");
                        key = key.substr(k_first, k_last - k_first + 1);
                    } else {
                        key = "";
                    }
                    p = colonPos + 1;
                    while (p < body.size() && (body[p] == ' ' || body[p] == '\t' || body[p] == '\r' || body[p] == '\n')) p++;
                    if (p < body.size() && body[p] == '[') {
                        size_t closeBrk = body.find(']', p);
                        if (closeBrk == std::string::npos) break;
                        std::string arrInner = body.substr(p + 1, closeBrk - p - 1);
                        std::vector<std::string> arrVals;
                        std::stringstream ass(arrInner);
                        std::string aitem;
                        while (std::getline(ass, aitem, ',')) {
                            size_t a_first = aitem.find_first_not_of(" \t\r\n\"");
                            if (a_first != std::string::npos) {
                                size_t a_last = aitem.find_last_not_of(" \t\r\n\"");
                                aitem = aitem.substr(a_first, a_last - a_first + 1);
                                if (!aitem.empty()) arrVals.push_back(aitem);
                            }
                        }
                        arrMembers[key] = arrVals;
                        p = closeBrk + 1;
                        while (p < body.size() && (body[p] == ' ' || body[p] == '\t' || body[p] == '\r' || body[p] == '\n')) p++;
                        if (p < body.size() && body[p] == ',') p++;
                    } else {
                        bool inQuote = false;
                        char qChar = '\0';
                        size_t valStart = p;
                        while (p < body.size()) {
                            if (!inQuote && (body[p] == '"' || body[p] == '\'')) { inQuote = true; qChar = body[p]; p++; continue; }
                            if (inQuote && body[p] == qChar) { inQuote = false; p++; continue; }
                            if (!inQuote && body[p] == ',') break;
                            p++;
                        }
                        std::string val = body.substr(valStart, p - valStart);
                        size_t v_first = val.find_first_not_of(" \t\r\n\"\'");
                        if (v_first != std::string::npos) {
                            size_t v_last = val.find_last_not_of(" \t\r\n\"\'");
                            val = val.substr(v_first, v_last - v_first + 1);
                        } else {
                            val = "";
                        }
                        members[key] = val;
                        while (p < body.size() && (body[p] == ' ' || body[p] == '\t' || body[p] == '\r' || body[p] == '\n')) p++;
                        if (p < body.size() && body[p] == ',') p++;
                    }
                }
                ctx.sessionObjEnv[objName] = members;
                if (!arrMembers.empty()) ctx.sessionObjArrays[objName] = arrMembers;
                ctx.persistentObjVars.insert(objName);
                continue;
            }
            
            size_t eqPos = line.find('=');
            if (eqPos == std::string::npos) continue;
            
            std::string name = line.substr(0, eqPos);
            std::string value = line.substr(eqPos + 1);
            
            name.erase(0, name.find_first_not_of(" \t"));
            name.erase(name.find_last_not_of(" \t\r\n") + 1);
            value.erase(0, value.find_first_not_of(" \t"));
            value.erase(value.find_last_not_of(" \t\r\n") + 1);
            
            if (name.size() >= 2 && name.substr(name.size() - 2) == "[]") {
                std::string arrName = name.substr(0, name.size() - 2);
                std::vector<std::string> arr;
                
                if (value.size() >= 2 && value[0] == '{' && value[value.size() - 1] == '}') {
                    std::string inner = value.substr(1, value.size() - 2);
                    std::stringstream ss(inner);
                    std::string item;
                    while (std::getline(ss, item, ',')) {
                        item.erase(0, item.find_first_not_of(" \t"));
                        item.erase(item.find_last_not_of(" \t") + 1);
                        arr.push_back(item);
                    }
                }
                
                ctx.sessionArrayEnv[arrName] = arr;
                ctx.persistentArrayVars.insert(arrName);
            } else {
                ctx.sessionEnv[name] = value;
                ctx.persistentVars.insert(name);
                SetEnvironmentVariableA(name.c_str(), value.c_str());
            }
        }
    }

    void savePersistentVars() {
        std::ofstream file(getVarFilePath());
        if (!file) return;
        
        file << "# Linuxify Persistent Variables\n";
        file << "# Format: VAR=value or ARR[]={val1,val2,val3}\n\n";
        
        for (const auto& varName : ctx.persistentVars) {
            auto it = ctx.sessionEnv.find(varName);
            if (it != ctx.sessionEnv.end()) {
                file << it->first << "=" << it->second << "\n";
            }
        }
        
        for (const auto& arrName : ctx.persistentArrayVars) {
            auto it = ctx.sessionArrayEnv.find(arrName);
            if (it != ctx.sessionArrayEnv.end()) {
                file << it->first << "[]={";
                for (size_t i = 0; i < it->second.size(); ++i) {
                    if (i > 0) file << ",";
                    file << it->second[i];
                }
                file << "}\n";
            }
        }
        
        for (const auto& objName : ctx.persistentObjVars) {
            auto scalarIt = ctx.sessionObjEnv.find(objName);
            auto arrayIt = ctx.sessionObjArrays.find(objName);
            if (scalarIt == ctx.sessionObjEnv.end() && arrayIt == ctx.sessionObjArrays.end()) continue;
            file << "OBJ:" << objName << "{";
            bool first = true;
            if (scalarIt != ctx.sessionObjEnv.end()) {
                for (const auto& member : scalarIt->second) {
                    if (!first) file << ",";
                    first = false;
                    file << member.first << ":\"" << member.second << "\"";
                }
            }
            if (arrayIt != ctx.sessionObjArrays.end()) {
                for (const auto& arrMember : arrayIt->second) {
                    if (!first) file << ",";
                    first = false;
                    file << arrMember.first << ":[";
                    for (size_t i = 0; i < arrMember.second.size(); ++i) {
                        if (i > 0) file << ",";
                        file << "\"" << arrMember.second[i] << "\"";
                    }
                    file << "]";
                }
            }
            file << "}\n";
        }
    }

    std::string parseAnsiEscape(const std::string& raw) {
        std::string result = raw;
        size_t pos = 0;
        while ((pos = result.find("\\e[", pos)) != std::string::npos) {
            result.replace(pos, 3, "\033[");
            pos += 2;
        }
        pos = 0;
        while ((pos = result.find("\\033[", pos)) != std::string::npos) {
            result.replace(pos, 5, "\033[");
            pos += 2;
        }
        return result;
    }

    void loadLinuxifyRC() {
        const char* userProfile = getenv("USERPROFILE");
        if (!userProfile) return;
        
        std::string rcPath = std::string(userProfile) + "\\.linuxifyrc";
        
        if (!fs::exists(rcPath)) {
            std::ofstream newRc(rcPath);
            if (newRc) {
                newRc << "# ============================================================\n";
                newRc << "# Linuxify Startup Configuration (~/.linuxifyrc)\n";
                newRc << "# ============================================================\n";
                newRc << "# This file is executed when Linuxify starts.\n";
                newRc << "# Lines starting with # are comments and are ignored.\n";
                newRc << "#\n";
                newRc << "# PROMPT CUSTOMIZATION:\n";
                newRc << "#   Prompt:First(\\e[92m)   - Color for 'linuxify' text\n";
                newRc << "#   Prompt:Second(\\e[94m)  - Color for path\n";
                newRc << "#\n";
                newRc << "# ANSI Colors: \\e[91m=Red \\e[92m=Green \\e[93m=Yellow\n";
                newRc << "#              \\e[94m=Blue \\e[95m=Magenta \\e[96m=Cyan\n";
                newRc << "#\n";
                newRc << "# ALIASES:\n";
                newRc << "#   alias ll=\"ls -la\"\n";
                newRc << "#   alias gs=\"git status\"\n";
                newRc << "#\n";
                newRc << "# ENVIRONMENT:\n";
                newRc << "#   export EDITOR=lino\n";
                newRc << "#\n";
                newRc << "# STARTUP COMMANDS:\n";
                newRc << "#   echo -e \"\\e[92mWelcome!\\e[0m\"\n";
                newRc << "#\n";
                newRc.close();
            }
        }
        
        std::ifstream file(rcPath);
        if (!file) return;
        
        std::string line;
        std::vector<std::string> commands;
        
        while (std::getline(file, line)) {
            if (line.empty() || line[0] == '#') continue;
            
            line.erase(0, line.find_first_not_of(" \t"));
            line.erase(line.find_last_not_of(" \t\r\n") + 1);
            
            if (line.rfind("Prompt:First(", 0) == 0) {
                size_t start = 13;
                size_t end = line.find(')', start);
                if (end != std::string::npos) {
                    std::string color = line.substr(start, end - start);
                    PromptConfig::firstColor = parseAnsiEscape(color);
                }
            } else if (line.rfind("Prompt:Second(", 0) == 0) {
                size_t start = 14;
                size_t end = line.find(')', start);
                if (end != std::string::npos) {
                    std::string color = line.substr(start, end - start);
                    PromptConfig::secondColor = parseAnsiEscape(color);
                }
            } else {
                commands.push_back(line);
            }
        }
        
        for (const auto& cmd : commands) {
            ctx.interpreter.runCode(cmd);
        }
    }

    std::string expandVariables(const std::string& input) {
        std::string text = input;
        size_t pos = 0;
        
        while ((pos = text.find('$', pos)) != std::string::npos) {
            size_t end = pos + 1;
            
            if (end >= text.length()) break;
            
            if (text[end] == '(') {
                // Find matching closing paren (handle nested parens)
                int parenDepth = 1;
                size_t close = end + 1;
                while (close < text.length() && parenDepth > 0) {
                    if (text[close] == '(') parenDepth++;
                    else if (text[close] == ')') parenDepth--;
                    close++;
                }
                close--;  // Point to the actual closing paren
                
                if (close < text.length()) {
                    std::string inner = text.substr(end + 1, close - end - 1);
                    std::string value;
                    
                    if (inner == "RANDOM" || inner.rfind("RANDOM ", 0) == 0 || inner.rfind("RANDOM%", 0) == 0) {
                        int maxVal = 32768;
                        size_t pct = inner.find('%');
                        if (pct != std::string::npos) {
                            try { maxVal = std::stoi(inner.substr(pct + 1)); } catch (...) {}
                            if (maxVal == 0) maxVal = 32768;
                        }
                        int offset = 0;
                        size_t replaceEnd = close + 1;
                        if (replaceEnd < text.length() && (text[replaceEnd] == '+' || text[replaceEnd] == '-')) {
                            bool neg = (text[replaceEnd] == '-');
                            size_t numStart = replaceEnd + 1;
                            size_t numEnd = numStart;
                            if (numEnd < text.length() && (text[numEnd] == '+' || text[numEnd] == '-')) numEnd++;
                            while (numEnd < text.length() && std::isdigit(text[numEnd])) numEnd++;
                            if (numEnd > numStart) {
                                try { offset = std::stoi(text.substr(numStart, numEnd - numStart)); } catch (...) {}
                                if (neg) offset = -offset;
                                replaceEnd = numEnd;
                            }
                        }
                        int raw = 0;
                        if (pct != std::string::npos) {
                            int high = std::max(maxVal, offset);
                            int low = std::min(maxVal, offset);
                            int range = high - low + 1;
                            if (range <= 0) range = 1;
                            raw = (rand() % range) + low;
                        } else {
                            raw = (rand() % 32768) + offset;
                        }
                        value = std::to_string(raw);
                        text = text.substr(0, pos) + value + text.substr(replaceEnd);
                        continue;
                    }
                    
                    // Check if this is array access $(arr[idx])
                    size_t bracket = inner.find('[');
                    if (bracket != std::string::npos && inner.back() == ']') {
                        std::string arrName = inner.substr(0, bracket);
                        std::string idxStr = inner.substr(bracket + 1, inner.size() - bracket - 2);
                        auto it = ctx.sessionArrayEnv.find(arrName);
                        if (it != ctx.sessionArrayEnv.end()) {
                            if (idxStr == "*" || idxStr == "@") {
                                for(size_t i=0; i<it->second.size(); i++) {
                                    if(i>0) value += " ";
                                    value += it->second[i];
                                }
                            } else {
                                try {
                                    size_t idx = std::stoul(idxStr);
                                    if (idx < it->second.size()) {
                                        value = it->second[idx];
                                    }
                                } catch (...) {}
                            }
                        }
                    } 
                    else if (inner.find(' ') == std::string::npos && 
                             inner.find('\t') == std::string::npos) {
                        if (inner == "RANDOM") {
                            value = std::to_string(rand() % 32768);
                        } else {
                            auto it = ctx.sessionEnv.find(inner);
                            if (it != ctx.sessionEnv.end()) {
                                value = it->second;
                            } else {
                                const char* envVal = getenv(inner.c_str());
                                if (envVal) { 
                                    value = envVal; 
                                } else {
                                    if (Arith::isArithmeticExpression(inner)) {
                                        try {
                                            value = Arith::evaluate(inner);
                                        } catch (...) {
                                            value = executeAndCapture(inner);
                                            while (!value.empty() && (value.back() == '\n' || value.back() == '\r')) {
                                                value.pop_back();
                                            }
                                        }
                                    } else {
                                        value = executeAndCapture(inner);
                                        while (!value.empty() && (value.back() == '\n' || value.back() == '\r')) {
                                            value.pop_back();
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else {
                        if (Arith::isArithmeticExpression(inner)) {
                            try {
                                value = Arith::evaluate(inner);
                            } catch (...) {
                                value = executeAndCapture(inner);
                                while (!value.empty() && (value.back() == '\n' || value.back() == '\r')) {
                                    value.pop_back();
                                }
                            }
                        } else {
                            value = executeAndCapture(inner);
                            while (!value.empty() && (value.back() == '\n' || value.back() == '\r')) {
                                value.pop_back();
                            }
                        }
                    }
                    text = text.substr(0, pos) + value + text.substr(close + 1);
                    continue;
                }
            } else if (text[end] == '{') {
                size_t close = text.find('}', end + 1);
                if (close != std::string::npos) {
                    std::string varName = text.substr(end + 1, close - end - 1);
                    std::string value;
                    if (varName == "RANDOM") {
                        value = std::to_string(rand() % 32768);
                    } else {
                        size_t dotPos = varName.find('.');
                        if (dotPos != std::string::npos) {
                            std::string objName = varName.substr(0, dotPos);
                            std::string memberName = varName.substr(dotPos + 1);
                            
                            size_t bracketIdx = memberName.find('[');
                            if (bracketIdx != std::string::npos && memberName.back() == ']') {
                                std::string arrMemName = memberName.substr(0, bracketIdx);
                                std::string idxStr = memberName.substr(bracketIdx + 1, memberName.length() - bracketIdx - 2);
                                auto objIt = ctx.sessionObjArrays.find(objName);
                                if (objIt != ctx.sessionObjArrays.end()) {
                                    auto memIt = objIt->second.find(arrMemName);
                                    if (memIt != objIt->second.end()) {
                                        if (idxStr == "*" || idxStr == "@") {
                                            for(size_t ai=0; ai<memIt->second.size(); ai++) {
                                                if(ai>0) value += " ";
                                                value += memIt->second[ai];
                                            }
                                        } else {
                                            try {
                                                size_t idx = std::stoul(idxStr);
                                                if (idx < memIt->second.size()) value = memIt->second[idx];
                                            } catch (...) {}
                                        }
                                    }
                                }
                            } else {
                                auto objIt = ctx.sessionObjEnv.find(objName);
                                if (objIt != ctx.sessionObjEnv.end()) {
                                    auto memIt = objIt->second.find(memberName);
                                    if (memIt != objIt->second.end()) {
                                        value = memIt->second;
                                    }
                                }
                            }
                        } else {
                            auto it = ctx.sessionEnv.find(varName);
                            if (it != ctx.sessionEnv.end()) {
                                value = it->second;
                            } else {
                                const char* envVal = getenv(varName.c_str());
                                if (envVal) { value = envVal; }
                            }
                        }
                    }
                    text = text.substr(0, pos) + value + text.substr(close + 1);
                    continue;
                }
            } else if (isalnum(text[end]) || text[end] == '_') {
                while (end < text.length() && (isalnum(text[end]) || text[end] == '_')) {
                    end++;
                }
                
                if (end < text.length() && text[end] == '.') {
                    std::string objName = text.substr(pos + 1, end - (pos + 1));
                    size_t memberStart = end + 1;
                    size_t memberEnd = memberStart;
                    while (memberEnd < text.length() && (isalnum(text[memberEnd]) || text[memberEnd] == '_')) {
                        memberEnd++;
                    }
                    std::string memberName = text.substr(memberStart, memberEnd - memberStart);
                    if (!memberName.empty()) {
                        if (memberEnd < text.length() && text[memberEnd] == '[') {
                            size_t closeBracket = text.find(']', memberEnd + 1);
                            if (closeBracket != std::string::npos) {
                                std::string idxStr = text.substr(memberEnd + 1, closeBracket - memberEnd - 1);
                                std::string val;
                                auto objIt = ctx.sessionObjArrays.find(objName);
                                if (objIt != ctx.sessionObjArrays.end()) {
                                    auto memIt = objIt->second.find(memberName);
                                    if (memIt != objIt->second.end()) {
                                        if (idxStr == "*" || idxStr == "@") {
                                            for (size_t ai = 0; ai < memIt->second.size(); ai++) {
                                                if (ai > 0) val += " ";
                                                val += memIt->second[ai];
                                            }
                                        } else {
                                            try {
                                                size_t idx = std::stoul(idxStr);
                                                if (idx < memIt->second.size()) val = memIt->second[idx];
                                            } catch (...) {}
                                        }
                                    }
                                }
                                text = text.substr(0, pos) + val + text.substr(closeBracket + 1);
                                continue;
                            }
                        }
                        std::string val;
                        auto objIt = ctx.sessionObjEnv.find(objName);
                        if (objIt != ctx.sessionObjEnv.end()) {
                            auto memIt = objIt->second.find(memberName);
                            if (memIt != objIt->second.end()) val = memIt->second;
                        }
                        text = text.substr(0, pos) + val + text.substr(memberEnd);
                        continue;
                    }
                }
                
                if (end < text.length() && text[end] == '[') {
                    size_t closeBracket = text.find(']', end + 1);
                    if (closeBracket != std::string::npos) {
                        std::string varName = text.substr(pos + 1, end - (pos + 1));
                        std::string idxStr = text.substr(end + 1, closeBracket - end - 1);
                        std::string val;
                        
                        auto it = ctx.sessionArrayEnv.find(varName);
                        if (it != ctx.sessionArrayEnv.end()) {
                            try {
                                size_t idx = std::stoul(idxStr);
                                if (idx < it->second.size()) {
                                    val = it->second[idx];
                                }
                            } catch (...) {}
                        }
                        
                        text = text.substr(0, pos) + val + text.substr(closeBracket + 1);
                        continue;
                    }
                }

                std::string varName = text.substr(pos + 1, end - pos - 1);
                std::string value;
                if (varName == "RANDOM") {
                    value = std::to_string(rand() % 32768);
                } else {
                    auto it = ctx.sessionEnv.find(varName);
                    if (it != ctx.sessionEnv.end()) {
                        value = it->second;
                    } else {
                        const char* envVal = getenv(varName.c_str());
                        if (envVal) { value = envVal; }
                    }
                }
                text = text.substr(0, pos) + value + text.substr(end);
                continue;
            }
            pos++;
        }
        
        return text;
    }

    std::vector<std::string> expandTokens(const std::vector<std::string>& tokens) {
        std::vector<std::string> expanded;
        for (const auto& token : tokens) {
            std::string exp = expandVariables(token);
            
            size_t bracketPos = exp.find('[');
            if (bracketPos != std::string::npos && exp.size() > bracketPos + 2) {
                std::string afterBracket = exp.substr(bracketPos + 1);
                if (afterBracket == "*]" || afterBracket == "@]") {
                    std::string arrName = exp.substr(0, bracketPos);
                    auto it = ctx.sessionArrayEnv.find(arrName);
                    if (it != ctx.sessionArrayEnv.end() && !it->second.empty()) {
                        for (const auto& elem : it->second) {
                            expanded.push_back(elem);
                        }
                        continue;
                    }
                }
            }
            
            if (Glob::containsGlob(exp)) {
                auto matches = Glob::expandGlob(exp, ctx.currentDir);
                for (const auto& m : matches) {
                    expanded.push_back(m);
                }
            } else {
                expanded.push_back(exp);
            }
        }
        return expanded;
    }

    void cmdHistory(const std::vector<std::string>& args) {
        bool showNumbers = true;
        int limit = -1;  // -1 means show all
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-c" || args[i] == "--clear" || args[i] == "clear") {
                // Clear history
                ctx.commandHistory.clear();
                std::ofstream file(getHistoryFilePath(), std::ios::trunc);
                printSuccess("History cleared.");
                return;
            } else {
                try {
                    limit = std::stoi(args[i]);
                } catch (...) {}
            }
        }
        
        size_t start = 0;
        if (limit > 0 && limit < (int)ctx.commandHistory.size()) {
            start = ctx.commandHistory.size() - limit;
        }
        
        for (size_t i = start; i < ctx.commandHistory.size(); ++i) {
            if (showNumbers) {
                std::cout << std::setw(5) << (i + 1) << "  ";
            }
            std::cout << ctx.commandHistory[i] << std::endl;
        }
    }

    // whoami - show current user
    void cmdWhoami(const std::vector<std::string>& args) {
        char username[256];
        DWORD size = sizeof(username);
        
        if (GetUserNameA(username, &size)) {
            std::cout << username << std::endl;
        } else {
            // Fallback to environment variable
            const char* user = getenv("USERNAME");
            if (user) {
                std::cout << user << std::endl;
            } else {
                printError("whoami: cannot determine username");
            }
        }
    }

    void cmdEcho(const std::vector<std::string>& args) {
        bool newline = true;
        bool interpretEscapes = false;
        size_t start = 1;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-n") { newline = false; start = i + 1; }
            else if (args[i] == "-e") { interpretEscapes = true; start = i + 1; }
            else if (args[i] == "-E") { interpretEscapes = false; start = i + 1; }
            else if (args[i] == "-ne" || args[i] == "-en") { newline = false; interpretEscapes = true; start = i + 1; }
            else break;
        }
        
        auto processEscapes = [](const std::string& input) -> std::string {
            std::string result;
            for (size_t i = 0; i < input.length(); ++i) {
                if (input[i] == '\\' && i + 1 < input.length()) {
                    char next = input[i + 1];
                    if (next == 'n') { result += '\n'; i++; }
                    else if (next == 't') { result += '\t'; i++; }
                    else if (next == 'r') { result += '\r'; i++; }
                    else if (next == 'a') { result += '\a'; i++; }
                    else if (next == 'b') { result += '\b'; i++; }
                    else if (next == 'v') { result += '\v'; i++; }
                    else if (next == 'f') { result += '\f'; i++; }
                    else if (next == '\\') { result += '\\'; i++; }
                    else if (next == '0') {
                        int val = 0;
                        size_t j = i + 2;
                        while (j < input.length() && j < i + 5 && input[j] >= '0' && input[j] <= '7') {
                            val = val * 8 + (input[j] - '0');
                            j++;
                        }
                        result += (char)val;
                        i = j - 1;
                    }
                    else if (next == 'x') {
                        int val = 0;
                        size_t j = i + 2;
                        while (j < input.length() && j < i + 4) {
                            char c = input[j];
                            if (c >= '0' && c <= '9') val = val * 16 + (c - '0');
                            else if (c >= 'a' && c <= 'f') val = val * 16 + (c - 'a' + 10);
                            else if (c >= 'A' && c <= 'F') val = val * 16 + (c - 'A' + 10);
                            else break;
                            j++;
                        }
                        result += (char)val;
                        i = j - 1;
                    }
                    else if (next == 'e' || next == 'E') { result += '\033'; i++; }
                    else if (next == 'c') { return result; }
                    else { result += input[i]; }
                } else {
                    result += input[i];
                }
            }
            return result;
        };
        
        for (size_t i = start; i < args.size(); ++i) {
            std::string text = args[i];
            
            size_t pos = 0;
            while ((pos = text.find('$', pos)) != std::string::npos) {
                size_t end = pos + 1;
                
                if (end < text.length() && text[end] == '(') {
                    size_t close = text.find(')', end + 1);
                    if (close != std::string::npos) {
                        std::string inner = text.substr(end + 1, close - end - 1);
                        std::string value;
                        
                        if (inner == "RANDOM" || inner.rfind("RANDOM ", 0) == 0 || inner.rfind("RANDOM%", 0) == 0) {
                            int maxVal = 32768;
                            size_t pct = inner.find('%');
                            if (pct != std::string::npos) {
                                try { maxVal = std::stoi(inner.substr(pct + 1)); } catch (...) {}
                                if (maxVal == 0) maxVal = 32768;
                            }
                            int offset = 0;
                            size_t replaceEnd = close + 1;
                            if (replaceEnd < text.length() && (text[replaceEnd] == '+' || text[replaceEnd] == '-')) {
                                bool neg = (text[replaceEnd] == '-');
                                size_t numStart = replaceEnd + 1;
                                size_t numEnd = numStart;
                                if (numEnd < text.length() && (text[numEnd] == '+' || text[numEnd] == '-')) numEnd++;
                                while (numEnd < text.length() && std::isdigit(text[numEnd])) numEnd++;
                                if (numEnd > numStart) {
                                    try { offset = std::stoi(text.substr(numStart, numEnd - numStart)); } catch (...) {}
                                    if (neg) offset = -offset;
                                    replaceEnd = numEnd;
                                }
                            }
                            int raw = 0;
                            if (pct != std::string::npos) {
                                int high = std::max(maxVal, offset);
                                int low = std::min(maxVal, offset);
                                int range = high - low + 1;
                                if (range <= 0) range = 1;
                                raw = (rand() % range) + low;
                            } else {
                                raw = (rand() % 32768) + offset;
                            }
                            value = std::to_string(raw);
                            text = text.substr(0, pos) + value + text.substr(replaceEnd);
                            continue;
                        }
                        
                        size_t bracket = inner.find('[');
                        if (bracket != std::string::npos && inner.back() == ']') {
                            std::string arrName = inner.substr(0, bracket);
                            std::string idxStr = inner.substr(bracket + 1, inner.size() - bracket - 2);
                            auto it = ctx.sessionArrayEnv.find(arrName);
                            if (it != ctx.sessionArrayEnv.end()) {
                                try {
                                    size_t idx = std::stoul(idxStr);
                                    if (idx < it->second.size()) {
                                        value = it->second[idx];
                                    }
                                } catch (...) {}
                            }
                        } else {
                            if (inner == "RANDOM") {
                                value = std::to_string(rand() % 32768);
                            } else {
                                auto it = ctx.sessionEnv.find(inner);
                                if (it != ctx.sessionEnv.end()) {
                                    value = it->second;
                                } else {
                                    const char* envVal = getenv(inner.c_str());
                                    if (envVal) { value = envVal; }
                                }
                            }
                        }
                        text = text.substr(0, pos) + value + text.substr(close + 1);
                        continue;
                    }
                } else if (end < text.length() && text[end] == '{') {
                    size_t close = text.find('}', end + 1);
                    if (close != std::string::npos) {
                        std::string varName = text.substr(end + 1, close - end - 1);
                        std::string value;
                        if (varName == "RANDOM") {
                            value = std::to_string(rand() % 32768);
                        } else {
                            auto it = ctx.sessionEnv.find(varName);
                            if (it != ctx.sessionEnv.end()) {
                                value = it->second;
                            } else {
                                const char* envVal = getenv(varName.c_str());
                                if (envVal) { value = envVal; }
                            }
                        }
                        text = text.substr(0, pos) + value + text.substr(close + 1);
                        continue;
                    }
                } else {
                    while (end < text.length() && (isalnum(text[end]) || text[end] == '_')) {
                        end++;
                    }
                    std::string varName = text.substr(pos + 1, end - pos - 1);
                    std::string value;
                    if (varName == "RANDOM") {
                        value = std::to_string(rand() % 32768);
                    } else {
                        auto it = ctx.sessionEnv.find(varName);
                        if (it != ctx.sessionEnv.end()) {
                            value = it->second;
                        } else {
                            const char* envVal = getenv(varName.c_str());
                            if (envVal) { value = envVal; }
                        }
                    }
                    text = text.substr(0, pos) + value + text.substr(end);
                    continue;
                }
                pos++;
            }
            
            if (interpretEscapes) {
                text = processEscapes(text);
            }
            
            if (i > start) std::cout << " ";
            std::cout << text;
        }
        
        if (newline) std::cout << std::endl;
    }

    // env/printenv - show environment variables
    void cmdEnv(const std::vector<std::string>& args) {
        // If specific variable requested
        if (args.size() > 1) {
            std::string varName = args[1];
            
            // Check session env first
            auto it = ctx.sessionEnv.find(varName);
            if (it != ctx.sessionEnv.end()) {
                std::cout << it->second << std::endl;
                return;
            }
            
            const char* value = getenv(varName.c_str());
            if (value) {
                std::cout << value << std::endl;
            }
            return;
        }
        
        // Show all environment variables
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        
        // First show session variables
        if (!ctx.sessionEnv.empty()) {
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "# Session Variables:\n";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            for (const auto& pair : ctx.sessionEnv) {
                std::cout << pair.first << "=" << pair.second << std::endl;
            }
            std::cout << std::endl;
        }
        
        if (!ctx.sessionObjEnv.empty() || !ctx.sessionObjArrays.empty()) {
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "# Environmental Objects:\n";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            std::set<std::string> objNames;
            for (const auto& pair : ctx.sessionObjEnv) objNames.insert(pair.first);
            for (const auto& pair : ctx.sessionObjArrays) objNames.insert(pair.first);
            for (const auto& objName : objNames) {
                bool isPersistent = ctx.persistentObjVars.find(objName) != ctx.persistentObjVars.end();
                std::cout << objName << (isPersistent ? " [persistent]" : "") << "{";
                bool first = true;
                auto scIt = ctx.sessionObjEnv.find(objName);
                if (scIt != ctx.sessionObjEnv.end()) {
                    for (const auto& mem : scIt->second) {
                        if (!first) std::cout << ",";
                        first = false;
                        std::cout << mem.first << ":" << mem.second;
                    }
                }
                auto arIt = ctx.sessionObjArrays.find(objName);
                if (arIt != ctx.sessionObjArrays.end()) {
                    for (const auto& mem : arIt->second) {
                        if (!first) std::cout << ",";
                        first = false;
                        std::cout << mem.first << ":[";
                        for (size_t ai = 0; ai < mem.second.size(); ai++) {
                            if (ai > 0) std::cout << ",";
                            std::cout << mem.second[ai];
                        }
                        std::cout << "]";
                    }
                }
                std::cout << "}" << std::endl;
            }
            std::cout << std::endl;
        }
        
        char* envStrings = GetEnvironmentStringsA();
        if (envStrings) {
            char* current = envStrings;
            while (*current) {
                std::cout << current << std::endl;
                current += strlen(current) + 1;
            }
            FreeEnvironmentStringsA(envStrings);
        }
    }

    void parseObjBody(const std::string& body, std::map<std::string, std::string>& members, std::map<std::string, std::vector<std::string>>& arrMembers) {
        size_t p = 0;
        while (p < body.size()) {
            while (p < body.size() && (body[p] == ' ' || body[p] == '\t' || body[p] == '\r' || body[p] == '\n')) p++;
            if (p >= body.size()) break;
            size_t colonPos = body.find(':', p);
            if (colonPos == std::string::npos) break;
            std::string key = body.substr(p, colonPos - p);
            size_t k_first = key.find_first_not_of(" \t\r\n");
            if (k_first != std::string::npos) {
                size_t k_last = key.find_last_not_of(" \t\r\n");
                key = key.substr(k_first, k_last - k_first + 1);
            } else {
                key = "";
            }
            p = colonPos + 1;
            while (p < body.size() && (body[p] == ' ' || body[p] == '\t' || body[p] == '\r' || body[p] == '\n')) p++;
            if (p < body.size() && body[p] == '[') {
                size_t closeBrk = std::string::npos;
                int depth = 0;
                for (size_t s = p; s < body.size(); s++) {
                    if (body[s] == '[') depth++;
                    else if (body[s] == ']') { depth--; if (depth == 0) { closeBrk = s; break; } }
                }
                if (closeBrk == std::string::npos) break;
                std::string arrInner = body.substr(p + 1, closeBrk - p - 1);
                std::vector<std::string> arrVals;
                size_t ap = 0;
                while (ap < arrInner.size()) {
                    while (ap < arrInner.size() && (arrInner[ap] == ' ' || arrInner[ap] == '\t' || arrInner[ap] == ',')) ap++;
                    if (ap >= arrInner.size()) break;
                    if (arrInner[ap] == '"' || arrInner[ap] == '\'') {
                        char q = arrInner[ap]; ap++;
                        size_t vs = ap;
                        while (ap < arrInner.size() && arrInner[ap] != q) ap++;
                        arrVals.push_back(arrInner.substr(vs, ap - vs));
                        if (ap < arrInner.size()) ap++;
                    } else {
                        size_t vs = ap;
                        while (ap < arrInner.size() && arrInner[ap] != ',') ap++;
                        std::string v = arrInner.substr(vs, ap - vs);
                        size_t v_first = v.find_first_not_of(" \t\r\n");
                        if (v_first != std::string::npos) {
                            size_t v_last = v.find_last_not_of(" \t\r\n");
                            v = v.substr(v_first, v_last - v_first + 1);
                        } else {
                            v = "";
                        }
                        if (!v.empty()) {
                            arrVals.push_back(v);
                        }
                    }
                }
                arrMembers[key] = arrVals;
                p = closeBrk + 1;
                while (p < body.size() && (body[p] == ' ' || body[p] == '\t' || body[p] == '\r' || body[p] == '\n')) p++;
                if (p < body.size() && body[p] == ',') p++;
            } else {
                bool inQuote = false;
                char qChar = '\0';
                size_t valStart = p;
                while (p < body.size()) {
                    if (!inQuote && (body[p] == '"' || body[p] == '\'')) { inQuote = true; qChar = body[p]; p++; continue; }
                    if (inQuote && body[p] == qChar) { inQuote = false; p++; continue; }
                    if (!inQuote && body[p] == ',') break;
                    p++;
                }
                std::string val = body.substr(valStart, p - valStart);
                size_t v_first = val.find_first_not_of(" \t\r\n\"\'");
                if (v_first != std::string::npos) {
                    size_t v_last = val.find_last_not_of(" \t\r\n\"\'");
                    val = val.substr(v_first, v_last - v_first + 1);
                } else {
                    val = "";
                }
                members[key] = val;
                while (p < body.size() && (body[p] == ' ' || body[p] == '\t' || body[p] == '\r' || body[p] == '\n')) p++;
                if (p < body.size() && body[p] == ',') p++;
            }
        }
    }

    void cmdExport(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            for (const auto& pair : ctx.sessionEnv) {
                bool isPersistent = ctx.persistentVars.find(pair.first) != ctx.persistentVars.end();
                std::cout << "export " << (isPersistent ? "-p " : "") << pair.first << "=\"" << pair.second << "\"" << std::endl;
            }
            for (const auto& pair : ctx.sessionArrayEnv) {
                bool isPersistent = ctx.persistentArrayVars.find(pair.first) != ctx.persistentArrayVars.end();
                std::cout << "export " << (isPersistent ? "-p " : "") << "-arr " << pair.first << "={";
                for (size_t i = 0; i < pair.second.size(); ++i) {
                    if (i > 0) std::cout << ",";
                    std::cout << pair.second[i];
                }
                std::cout << "}" << std::endl;
            }
            std::set<std::string> objNames;
            for (const auto& p : ctx.sessionObjEnv) objNames.insert(p.first);
            for (const auto& p : ctx.sessionObjArrays) objNames.insert(p.first);
            for (const auto& objName : objNames) {
                bool isPersistent = ctx.persistentObjVars.find(objName) != ctx.persistentObjVars.end();
                std::cout << "export " << (isPersistent ? "-p " : "") << "-obj " << objName << "{";
                bool first = true;
                auto scIt = ctx.sessionObjEnv.find(objName);
                if (scIt != ctx.sessionObjEnv.end()) {
                    for (const auto& mem : scIt->second) {
                        if (!first) std::cout << ",";
                        first = false;
                        std::cout << mem.first << ":\"" << mem.second << "\"";
                    }
                }
                auto arIt = ctx.sessionObjArrays.find(objName);
                if (arIt != ctx.sessionObjArrays.end()) {
                    for (const auto& mem : arIt->second) {
                        if (!first) std::cout << ",";
                        first = false;
                        std::cout << mem.first << ":[";
                        for (size_t ai = 0; ai < mem.second.size(); ai++) {
                            if (ai > 0) std::cout << ",";
                            std::cout << "\"" << mem.second[ai] << "\"";
                        }
                        std::cout << "]";
                    }
                }
                std::cout << "}" << std::endl;
            }
            return;
        }
        
        bool persistent = false;
        bool isArray = false;
        bool isObj = false;
        
        std::string fullLine;
        for (size_t i = 1; i < args.size(); ++i) {
            if (i > 1) fullLine += " ";
            fullLine += args[i];
        }
        
        size_t scanPos = 0;
        while (scanPos < fullLine.size() && fullLine[scanPos] == ' ') scanPos++;
        while (scanPos < fullLine.size()) {
            if (fullLine.substr(scanPos, 2) == "-p") {
                persistent = true;
                scanPos += 2;
                while (scanPos < fullLine.size() && fullLine[scanPos] == ' ') scanPos++;
                continue;
            }
            if (fullLine.substr(scanPos, 4) == "-obj") {
                isObj = true;
                scanPos += 4;
                while (scanPos < fullLine.size() && fullLine[scanPos] == ' ') scanPos++;
                continue;
            }
            if (fullLine.substr(scanPos, 4) == "-arr") {
                isArray = true;
                scanPos += 4;
                while (scanPos < fullLine.size() && fullLine[scanPos] == ' ') scanPos++;
                continue;
            }
            break;
        }
        
        if (isObj) {
            std::string rest = fullLine.substr(scanPos);
            size_t braceStart = rest.find('{');
            if (braceStart == std::string::npos) {
                printError("export -obj: invalid format. Use: export -obj name{key:value,...}");
                return;
            }
            std::string objName = rest.substr(0, braceStart);
            size_t o_first = objName.find_first_not_of(" \t\r\n");
            if (o_first != std::string::npos) {
                size_t o_last = objName.find_last_not_of(" \t\r\n");
                objName = objName.substr(o_first, o_last - o_first + 1);
            } else {
                objName = "";
            }
            if (objName.empty()) {
                printError("export -obj: missing object name");
                return;
            }
            size_t braceEnd = std::string::npos;
            int depth = 0;
            for (size_t s = braceStart; s < rest.size(); s++) {
                if (rest[s] == '{') depth++;
                else if (rest[s] == '}') { depth--; if (depth == 0) { braceEnd = s; break; } }
            }
            if (braceEnd == std::string::npos) {
                printError("export -obj: missing closing }");
                return;
            }
            std::string body = rest.substr(braceStart + 1, braceEnd - braceStart - 1);
            std::map<std::string, std::string> members;
            std::map<std::string, std::vector<std::string>> arrMembers;
            parseObjBody(body, members, arrMembers);
            ctx.sessionObjEnv[objName] = members;
            if (!arrMembers.empty()) {
                ctx.sessionObjArrays[objName] = arrMembers;
            }
            if (persistent) {
                ctx.persistentObjVars.insert(objName);
                savePersistentVars();
            }
            size_t totalMembers = members.size() + arrMembers.size();
            printSuccess("Exported object: " + objName + " (" + std::to_string(totalMembers) + " members)" + (persistent ? " [persistent]" : ""));
            return;
        }
        
        std::map<std::string, std::vector<std::string>> parsedArrays;
        
        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            
            if (arg == "-p") {
                persistent = true;
                continue;
            }
            
            if (arg == "-arr") {
                isArray = true;
                continue;
            }
            
            if (arg == "-obj") {
                continue;
            }
            
            size_t eqPos = arg.find('=');
            
            if (eqPos == std::string::npos) {
                printError("export: invalid format. Use: export [-p] [-arr] NAME=value");
                continue;
            }
            
            std::string name = arg.substr(0, eqPos);
            
            size_t first = name.find_first_not_of(" \t\r\n");
            if (first == std::string::npos) continue;
            size_t last = name.find_last_not_of(" \t\r\n");
            name = name.substr(first, (last - first + 1));

            std::string value = arg.substr(eqPos + 1);
            
            if (value.length() >= 2 && 
                ((value.front() == '"' && value.back() == '"') ||
                 (value.front() == '\'' && value.back() == '\''))) {
                value = value.substr(1, value.length() - 2);
            }
            
            if (isArray) {
                if (value.size() >= 2 && value[0] == '{' && value.back() == '}') {
                    std::string inner = value.substr(1, value.size() - 2);
                    std::stringstream ss(inner);
                    std::string item;
                    while (std::getline(ss, item, ',')) {
                        item.erase(0, item.find_first_not_of(" \t"));
                        item.erase(item.find_last_not_of(" \t") + 1);
                        parsedArrays[name].push_back(item);
                    }
                } else {
                    parsedArrays[name].push_back(value);
                }
            } else {
                ctx.sessionEnv[name] = value;
                SetEnvironmentVariableA(name.c_str(), value.c_str());
                if (persistent) {
                    ctx.persistentVars.insert(name);
                    savePersistentVars();
                }
                printSuccess("Exported: " + name + "=" + value + (persistent ? " [persistent]" : ""));
            }
        }
        
        for (const auto& pair : parsedArrays) {
            ctx.sessionArrayEnv[pair.first] = pair.second;
            if (persistent) {
                ctx.persistentArrayVars.insert(pair.first);
            }
            printSuccess("Exported array: " + pair.first + " (" + std::to_string(pair.second.size()) + " elements)" + (persistent ? " [persistent]" : ""));
        }
        if (!parsedArrays.empty() && persistent) {
            savePersistentVars();
        }
    }

    // which - find command location
    void cmdWhich(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("which: missing argument");
            std::cout << "Usage: which <command>" << std::endl;
            return;
        }
        
        std::string cmd = args[1];
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        
        // Check built-in commands first
        std::vector<std::string> builtins = {
            "pwd", "cd", "ls", "mkdir", "rm", "mv", "cp", "touch", 
            "chmod", "chown", "clear", "help", "lino", "lin", "registry",
            "history", "whoami", "echo", "env", "printenv", "export", "which", "exit"
        };
        
        for (const auto& builtin : builtins) {
            if (cmd == builtin) {
                SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << cmd << ": shell built-in command" << std::endl;
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                return;
            }
        }
        
        // Check cmds folder
        char exePath[MAX_PATH];
        GetModuleFileNameA(NULL, exePath, MAX_PATH);
        fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
        
        std::vector<std::string> extensions = {".exe", ".cmd", ".bat", ""};
        for (const auto& ext : extensions) {
            fs::path cmdPath = cmdsDir / (cmd + ext);
            if (fs::exists(cmdPath)) {
                std::cout << cmdPath.string() << std::endl;
                return;
            }
        }
        
        // Check registry
        std::string regPath = g_registry.getExecutablePath(cmd);
        if (!regPath.empty()) {
            std::cout << regPath << std::endl;
            return;
        }
        
        printError("which: " + cmd + " not found");
    }

    // uninstall - Remove Linuxify from system
    void cmdUninstall(const std::vector<std::string>& args) {
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
        std::cout << "\n========================================" << std::endl;
        std::cout << "    LINUXIFY UNINSTALLER" << std::endl;
        std::cout << "========================================\n" << std::endl;
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        
        std::cout << "This will remove Linuxify from your system." << std::endl;
        std::cout << "The following will be removed:" << std::endl;
        std::cout << "  - Linuxify executable and related files" << std::endl;
        std::cout << "  - Linuxify from your system PATH" << std::endl;
        std::cout << "  - Windows Terminal integration" << std::endl;
        std::cout << std::endl;
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
        std::cout << "Are you sure you want to uninstall Linuxify? (yes/no): ";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        
        std::string response;
        std::getline(std::cin, response);
        
        // Normalize response
        std::transform(response.begin(), response.end(), response.begin(), ::tolower);
        response.erase(0, response.find_first_not_of(" \t"));
        response.erase(response.find_last_not_of(" \t") + 1);
        
        if (response != "yes" && response != "y") {
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "\nUninstall cancelled." << std::endl;
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            return;
        }
        
        std::cout << std::endl;
        
        // Get the installation directory
        char exePath[MAX_PATH];
        GetModuleFileNameA(NULL, exePath, MAX_PATH);
        fs::path installDir = fs::path(exePath).parent_path();
        
        std::cout << "Removing Linuxify from: " << installDir.string() << std::endl;
        
        // Try to remove from PATH using native Registry API
        std::cout << "Removing from system PATH..." << std::endl;
        
        // Remove from User PATH using native Registry API
        HKEY hEnvKey;
        if (RegOpenKeyExA(HKEY_CURRENT_USER, "Environment", 0, KEY_READ | KEY_WRITE, &hEnvKey) == ERROR_SUCCESS) {
            char pathBuf[8192];
            DWORD pathSize = sizeof(pathBuf);
            DWORD pathType;
            
            if (RegQueryValueExA(hEnvKey, "Path", NULL, &pathType, (BYTE*)pathBuf, &pathSize) == ERROR_SUCCESS) {
                std::string pathStr = pathBuf;
                std::string newPath;
                std::istringstream iss(pathStr);
                std::string segment;
                
                while (std::getline(iss, segment, ';')) {
                    // Skip segments containing "Linuxify"
                    std::string lowerSeg = segment;
                    std::transform(lowerSeg.begin(), lowerSeg.end(), lowerSeg.begin(), ::tolower);
                    if (lowerSeg.find("linuxify") == std::string::npos && !segment.empty()) {
                        if (!newPath.empty()) newPath += ";";
                        newPath += segment;
                    }
                }
                
                RegSetValueExA(hEnvKey, "Path", 0, pathType, (BYTE*)newPath.c_str(), (DWORD)newPath.length() + 1);
            }
            RegCloseKey(hEnvKey);
        }
        
        // Create a batch script to delete the folder after we exit
        std::string tempPath = std::getenv("TEMP") ? std::string(std::getenv("TEMP")) : "C:\\Windows\\Temp";
        std::string batchFile = tempPath + "\\linuxify_uninstall.bat";
        
        std::ofstream batch(batchFile);
        if (batch) {
            batch << "@echo off\n";
            batch << "echo Completing Linuxify uninstallation...\n";
            batch << "timeout /t 2 /nobreak > nul\n";  // Wait for the exe to close
            batch << "rd /s /q \"" << installDir.string() << "\" 2>nul\n";
            batch << "echo Linuxify has been completely removed.\n";
            batch << "echo.\n";
            batch << "del \"%~f0\"\n";  // Delete the batch file itself
            batch.close();
            
            // Start the batch file in a new window using ShellExecute (no cmd /c)
            ShellExecuteA(NULL, "open", batchFile.c_str(), NULL, NULL, SW_HIDE);
        }
        
        std::cout << std::endl;
        SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
        std::cout << "========================================" << std::endl;
        std::cout << "  Thank you for using Linuxify!" << std::endl;
        std::cout << "========================================" << std::endl;
        std::cout << std::endl;
        std::cout << "Goodbye! :)" << std::endl;
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << std::endl;
        
        ctx.running = false;
    }

    void cmdPs(const std::vector<std::string>& args) {
        bool allProcesses = false;
        bool fullFormat = false;
        bool extendedFormat = false;
        std::string filterUser;
        DWORD filterPid = 0;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-e" || args[i] == "-A" || args[i] == "aux" || args[i] == "-aux") {
                allProcesses = true;
                fullFormat = true;
            } else if (args[i] == "-f" || args[i] == "--full") {
                fullFormat = true;
            } else if (args[i] == "-l" || args[i] == "--long") {
                extendedFormat = true;
            } else if ((args[i] == "-u" || args[i] == "-U") && i + 1 < args.size()) {
                filterUser = args[++i];
                allProcesses = true;
            } else if (args[i] == "-p" && i + 1 < args.size()) {
                try { filterPid = std::stoul(args[++i]); } catch (...) {}
            }
        }

        HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnap == INVALID_HANDLE_VALUE) {
            printError("ps: failed to enumerate processes");
            return;
        }

        struct ProcInfo {
            DWORD pid;
            DWORD ppid;
            std::string name;
            size_t memoryKB;
            DWORD threads;
        };
        std::vector<ProcInfo> procs;

        PROCESSENTRY32 pe;
        pe.dwSize = sizeof(pe);
        if (Process32First(hSnap, &pe)) {
            do {
                if (filterPid != 0 && pe.th32ProcessID != filterPid) continue;
                
                ProcInfo info;
                info.pid = pe.th32ProcessID;
                info.ppid = pe.th32ParentProcessID;
                info.name = pe.szExeFile;
                info.threads = pe.cntThreads;
                info.memoryKB = 0;

                HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pe.th32ProcessID);
                if (hProc) {
                    PROCESS_MEMORY_COUNTERS pmc;
                    if (GetProcessMemoryInfo(hProc, &pmc, sizeof(pmc))) {
                        info.memoryKB = pmc.WorkingSetSize / 1024;
                    }
                    CloseHandle(hProc);
                }
                
                procs.push_back(info);
            } while (Process32Next(hSnap, &pe));
        }
        CloseHandle(hSnap);

        if (extendedFormat || fullFormat) {
            std::cout << std::left << std::setw(8) << "PID" 
                      << std::setw(8) << "PPID"
                      << std::setw(8) << "THR"
                      << std::setw(12) << "RSS(KB)"
                      << "COMMAND" << std::endl;
            
            for (const auto& p : procs) {
                std::cout << std::left << std::setw(8) << p.pid
                          << std::setw(8) << p.ppid
                          << std::setw(8) << p.threads
                          << std::setw(12) << p.memoryKB
                          << p.name << std::endl;
            }
        } else {
            std::cout << std::left << std::setw(8) << "PID" << "COMMAND" << std::endl;
            for (const auto& p : procs) {
                if (!allProcesses && p.pid == 0) continue;
                std::cout << std::left << std::setw(8) << p.pid << p.name << std::endl;
            }
        }
    }

    void cmdKill(const std::vector<std::string>& args) {
        static const std::map<std::string, int> signalMap = {
            {"SIGHUP", 1}, {"HUP", 1}, {"1", 1},
            {"SIGINT", 2}, {"INT", 2}, {"2", 2},
            {"SIGQUIT", 3}, {"QUIT", 3}, {"3", 3},
            {"SIGKILL", 9}, {"KILL", 9}, {"9", 9},
            {"SIGTERM", 15}, {"TERM", 15}, {"15", 15},
            {"SIGSTOP", 17}, {"STOP", 17}, {"17", 17},
            {"SIGCONT", 19}, {"CONT", 19}, {"19", 19}
        };

        if (args.size() >= 2 && (args[1] == "-l" || args[1] == "--list")) {
            std::cout << " 1) SIGHUP     2) SIGINT     3) SIGQUIT    9) SIGKILL\n";
            std::cout << "15) SIGTERM   17) SIGSTOP   19) SIGCONT\n";
            return;
        }

        if (args.size() < 2) {
            printError("kill: missing PID");
            return;
        }

        int signal = 15;
        std::vector<std::string> targets;

        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-s" && i + 1 < args.size()) {
                std::string sigName = args[++i];
                std::transform(sigName.begin(), sigName.end(), sigName.begin(), ::toupper);
                auto it = signalMap.find(sigName);
                if (it != signalMap.end()) {
                    signal = it->second;
                } else {
                    try { signal = std::stoi(sigName); } catch (...) {
                        printError("kill: invalid signal: " + sigName);
                        return;
                    }
                }
            } else if (args[i][0] == '-' && args[i].length() > 1 && std::isdigit(args[i][1])) {
                try { signal = std::stoi(args[i].substr(1)); } catch (...) {}
            } else if (args[i][0] == '-' && args[i].length() > 1 && std::isalpha(args[i][1])) {
                std::string sigName = args[i].substr(1);
                std::transform(sigName.begin(), sigName.end(), sigName.begin(), ::toupper);
                auto it = signalMap.find(sigName);
                if (it != signalMap.end()) signal = it->second;
            } else {
                targets.push_back(args[i]);
            }
        }

        for (const auto& target : targets) {
            if (target[0] == '%') {
                try {
                    int jobId = std::stoi(target.substr(1));
                    if (g_procMgr.killJob(jobId)) {
                        printSuccess("Job " + std::to_string(jobId) + " terminated.");
                    } else {
                        printError("kill: no such job: " + target);
                    }
                } catch (...) {
                    printError("kill: invalid job ID: " + target);
                }
            } else {
                try {
                    DWORD pid = std::stoul(target);
                    HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
                    if (hProc) {
                        if (TerminateProcess(hProc, signal)) {
                            printSuccess("Process " + target + " killed with signal " + std::to_string(signal));
                        } else {
                            printError("kill: failed to terminate process " + target);
                        }
                        CloseHandle(hProc);
                    } else {
                        printError("kill: (" + target + ") - No such process or access denied");
                    }
                } catch (...) {
                    printError("kill: invalid PID: " + target);
                }
            }
        }
    }

    // top - live process monitor
    void cmdTop(const std::vector<std::string>& args) {
        ProcessManager::topView();
    }

    // jobs - list background jobs
    void cmdJobs(const std::vector<std::string>& args) {
        g_procMgr.listJobs();
    }

    // fg - bring job to foreground
    void cmdFg(const std::vector<std::string>& args) {
        int jobId = 1;
        
        if (args.size() > 1) {
            std::string target = args[1];
            if (target[0] == '%') {
                target = target.substr(1);
            }
            try {
                jobId = std::stoi(target);
            } catch (...) {
                printError("fg: invalid job ID");
                return;
            }
        }
        
        BackgroundJob* job = g_procMgr.getJob(jobId);
        if (job) {
            if (job->suspended) {
                g_procMgr.resumeJob(jobId);
            }
            if (job->running || job->suspended) {
                std::cout << job->command << std::endl;
                g_procMgr.waitForJob(jobId);
            } else {
                printError("fg: job has already completed");
            }
        } else {
            printError("fg: no such job");
        }
    }

    // bg - resume job in background
    void cmdBg(const std::vector<std::string>& args) {
        int jobId = 1;
        
        if (args.size() > 1) {
            std::string target = args[1];
            if (target[0] == '%') {
                target = target.substr(1);
            }
            try {
                jobId = std::stoi(target);
            } catch (...) {
                printError("bg: invalid job ID");
                return;
            }
        }
        
        BackgroundJob* job = g_procMgr.getJob(jobId);
        if (job && job->suspended) {
            g_procMgr.resumeJob(jobId);
            std::cout << "[" << jobId << "]+ " << job->command << " &" << std::endl;
        } else if (job && job->running) {
            printError("bg: job is already running");
        } else {
            printError("bg: no such suspended job");
        }
    }

    // Run a command in background
    bool runInBackground(const std::string& cmdLine, const std::string& displayCmd) {
        STARTUPINFOA si;
        PROCESS_INFORMATION pi;
        ZeroMemory(&si, sizeof(si));
        si.cb = sizeof(si);
        si.dwFlags = STARTF_USESHOWWINDOW;
        si.wShowWindow = SW_HIDE;  // Hide the window
        ZeroMemory(&pi, sizeof(pi));
        
        char cmdBuffer[4096];
        strncpy_s(cmdBuffer, cmdLine.c_str(), sizeof(cmdBuffer));
        
        // CREATE_NEW_CONSOLE creates a separate console for the process
        // DETACHED_PROCESS would have no console at all
        DWORD creationFlags = CREATE_NEW_PROCESS_GROUP | CREATE_NEW_CONSOLE;
        
        if (CreateProcessA(
            NULL,
            cmdBuffer,
            NULL,
            NULL,
            FALSE,
            creationFlags,
            NULL,
            ctx.currentDir.c_str(),
            &si,
            &pi
        )) {
            int jobId = g_procMgr.addJob(pi.hProcess, pi.dwProcessId, displayCmd);
            CloseHandle(pi.hThread);
            
            std::cout << "[" << jobId << "] " << pi.dwProcessId << std::endl;
            return true;
        }
        
        return false;
    }


    // grep - search for pattern in file or input using buffered reading and regex
    void cmdGrep(const std::vector<std::string>& args, const std::string& pipedInput = "") {



        if (args.size() < 2) {
            printError("grep: missing pattern");
            std::cout << "Usage: grep [OPTIONS] PATTERN [FILE...]" << std::endl;
            return;
        }

        struct GrepOptions {
             bool ignoreCase = false;
             bool lineNumbers = false;
             bool invertMatch = false;
             bool countOnly = false;
             bool recursive = false;
             bool useRegex = false;
             bool showFilename = false; // Implicit if multiple files
             int context = 0;
        } opts;

        std::string pattern;
        std::vector<std::string> files;
        size_t argIdx = 1;

        // Argument Parsing
        for (; argIdx < args.size(); ++argIdx) {
            std::string arg = args[argIdx];
            if (arg[0] != '-') {
                 if (pattern.empty()) pattern = arg;
                 else files.push_back(arg);
            } else {
                 if (arg == "-i" || arg == "--ignore-case") opts.ignoreCase = true;
                 else if (arg == "-n" || arg == "--line-number") opts.lineNumbers = true;
                 else if (arg == "-v" || arg == "--invert-match") opts.invertMatch = true;
                 else if (arg == "-c" || arg == "--count") opts.countOnly = true;
                 else if (arg == "-r" || arg == "-R" || arg == "--recursive") opts.recursive = true;
                 else if (arg == "-E" || arg == "--extended-regexp") opts.useRegex = true;
                 else if (arg == "-h" || arg == "--no-filename") opts.showFilename = false;
                 else if (arg == "-H" || arg == "--with-filename") opts.showFilename = true;
                 else if (arg.rfind("-C", 0) == 0 && arg.length() > 2) opts.context = std::stoi(arg.substr(2));
                 else if (arg == "-C" && argIdx + 1 < args.size()) opts.context = std::stoi(args[++argIdx]);
                 else if (pattern.empty()) pattern = arg; // Handle negative pattern?? No, usually flags first
            }
        }
        
        if (pattern.empty()) {
             printError("grep: missing pattern");
             return;
        }

        if (files.empty() && opts.recursive) files.push_back(".");
        
        bool multipleFiles = files.size() > 1 || opts.recursive;
        if (opts.recursive) multipleFiles = true;
        int totalMatches = 0;

        std::regex regexPattern;
        try {
            if (opts.useRegex) {
                regexPattern = std::regex(pattern, opts.ignoreCase ? std::regex::icase : std::regex::ECMAScript);
            }
        } catch (...) {
            printError("grep: invalid regular expression");
            return;
        }

        auto performGrep = [&](std::istream& is, const std::string& filename) {
             std::string line;
             int lineNum = 0;
             int matches = 0;
             std::deque<std::string> contextBuffer; // For leading context
             int contextCountdown = 0; // For trailing context

             while (std::getline(is, line)) {
                 lineNum++;
                 bool found = false;
                 std::smatch sm;

                 if (opts.useRegex) {
                     found = std::regex_search(line, sm, regexPattern);
                 } else {
                     std::string searchLine = line;
                     std::string searchPat = pattern;
                     if (opts.ignoreCase) {
                         std::transform(searchLine.begin(), searchLine.end(), searchLine.begin(), ::tolower);
                         std::transform(searchPat.begin(), searchPat.end(), searchPat.begin(), ::tolower);
                     }
                     found = searchLine.find(searchPat) != std::string::npos;
                 }

                 if (opts.invertMatch) found = !found;

                 if (found) {
                     matches++;
                     if (opts.countOnly) continue;
                     
                     // Print Leading Context
                     if (opts.context > 0 && !contextBuffer.empty()) {
                          int cLine = lineNum - (int)contextBuffer.size();
                          for (const auto& cL : contextBuffer) {
                              if (multipleFiles || opts.showFilename) std::cout << filename << "-";
                              if (opts.lineNumbers) std::cout << cLine << "-";
                              std::cout << cL << std::endl;
                              cLine++;
                          }
                          contextBuffer.clear();
                     }

                     // Print Match
                     if (multipleFiles || opts.showFilename) {
                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                         std::cout << filename << ":";
                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                     }
                     if (opts.lineNumbers) {
                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                         std::cout << lineNum << ":";
                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                     }

                     // Highlight Pattern if not inverted
                     if (!opts.invertMatch && !opts.useRegex) {
                         // Basic highlight
                         size_t pos = 0;
                         std::string temp = line;
                         std::string searchTemp = temp;
                         if (opts.ignoreCase) std::transform(searchTemp.begin(), searchTemp.end(), searchTemp.begin(), ::tolower);
                         std::string searchPat = pattern;
                         if (opts.ignoreCase) std::transform(searchPat.begin(), searchPat.end(), searchPat.begin(), ::tolower);

                         while ((pos = searchTemp.find(searchPat)) != std::string::npos) {
                             std::cout << temp.substr(0, pos);
                             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_INTENSITY);
                             std::cout << temp.substr(pos, pattern.length());
                             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                             temp = temp.substr(pos + pattern.length());
                             searchTemp = searchTemp.substr(pos + searchPat.length());
                         }
                         std::cout << temp << std::endl;
                     } else {
                         std::cout << line << std::endl;
                     }
                     
                     contextCountdown = opts.context;
                 } else {
                     // Not found
                     if (contextCountdown > 0 && !opts.countOnly) {
                         if (multipleFiles || opts.showFilename) std::cout << filename << "-";
                         if (opts.lineNumbers) std::cout << lineNum << "-";
                         std::cout << line << std::endl;
                         contextCountdown--;
                     } else if (opts.context > 0) {
                         contextBuffer.push_back(line);
                         if (contextBuffer.size() > (size_t)opts.context) contextBuffer.pop_front();
                     }
                 }
             }

             if (opts.countOnly) {
                 if (multipleFiles || opts.showFilename) std::cout << filename << ":";
                 std::cout << matches << std::endl;
             }
             return matches;
        };

        if (files.empty()) {
            if (!pipedInput.empty()) {
                std::istringstream iss(pipedInput);
                totalMatches += performGrep(iss, "(standard input)");
            } else {
                // If no piped input string, try reading from stdin
                // This handles 'linuxify -c' pipeline cases
                totalMatches += performGrep(std::cin, "(standard input)");
            }
        } else {
            for (const auto& file : files) {
                if (opts.recursive && fs::is_directory(file)) {
                     try {
                         for (const auto& entry : fs::recursive_directory_iterator(file)) {
                             if (entry.is_regular_file()) {
                                 std::ifstream ifs(entry.path());
                                 if (ifs) totalMatches += performGrep(ifs, entry.path().string());
                             }
                         }
                     } catch (...) {}
                } else {
                     std::ifstream ifs(resolvePath(file));
                     if (!ifs) {
                         if (!opts.recursive) printError("grep: " + file + ": No such file or directory");
                         ctx.lastExitCode = 2;
                     } else {
                         totalMatches += performGrep(ifs, file);
                     }
                }
            }
        }
        
        ctx.lastExitCode = (totalMatches > 0) ? 0 : 1;
    }

    // head - output first part of files
    void cmdHead(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        long long count = 10;
        bool useBytes = false;
        bool quiet = false;
        bool verbose = false;
        std::vector<std::string> files;

        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "--help") {
                std::cout << "Usage: head [OPTION]... [FILE]...\n";
                std::cout << "Print the first 10 lines of each FILE to standard output.\n\n";
                std::cout << "Options:\n";
                std::cout << "  -n NUM        Print the first NUM lines instead of 10\n";
                std::cout << "  -c NUM        Print the first NUM bytes\n";
                std::cout << "  -q, --quiet   Never print headers giving file names\n";
                std::cout << "  -v, --verbose Always print headers giving file names\n";
                std::cout << "  -NUM          Shorthand for -n NUM\n";
                std::cout << "      --help    Display this help and exit\n";
                return;
            }
            else if (arg == "-n" && i + 1 < args.size()) count = std::stoll(args[++i]);
            else if (arg == "-c" && i + 1 < args.size()) { count = std::stoll(args[++i]); useBytes = true; }
            else if (arg == "-q" || arg == "--quiet" || arg == "--silent") quiet = true;
            else if (arg == "-v" || arg == "--verbose") verbose = true;
            else if (arg[0] == '-' && isdigit(arg[1])) count = std::abs(std::stoll(arg));
            else files.push_back(arg);
        }

        auto process = [&](std::istream& is, const std::string& name, bool showHeader) {
            if (showHeader) {
                std::cout << "==> " << name << " <==\n";
            }
            if (useBytes) {
                char buf[4096];
                long long remaining = count;
                while (remaining > 0 && is) {
                    long long toRead = (std::min)((long long)sizeof(buf), remaining);
                    is.read(buf, toRead);
                    std::cout.write(buf, is.gcount());
                    remaining -= is.gcount();
                }
            } else {
                std::string line;
                long long remaining = count;
                while (remaining > 0 && std::getline(is, line)) {
                    std::cout << line << "\n";
                    remaining--;
                }
            }
            if (showHeader) std::cout << "\n";
        };

        if (files.empty() && !pipedInput.empty()) {
            std::istringstream iss(pipedInput);
            process(iss, "", false);
        } else if (files.empty()) {
            process(std::cin, "", false);
        } else {
             bool showHeader = (files.size() > 1 && !quiet) || verbose;
             for (const auto& file : files) {
                 std::ifstream ifs(resolvePath(file), std::ios::binary);
                 if (!ifs) {
                     printError("head: cannot open '" + file + "'");
                     continue;
                 }
                 process(ifs, file, showHeader);
                 showHeader = (files.size() > 1 && !quiet);
             }
        }
    }

    // tail - output last part of files
    void cmdTail(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        long long count = 10;
        bool useBytes = false;
        bool follow = false;
        bool quiet = false;
        bool verbose = false;
        std::vector<std::string> files;
        int sleepInterval = 1000;

        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "--help") {
                std::cout << "Usage: tail [OPTION]... [FILE]...\n";
                std::cout << "Print the last 10 lines of each FILE to standard output.\n\n";
                std::cout << "Options:\n";
                std::cout << "  -n NUM        Print the last NUM lines instead of 10\n";
                std::cout << "  -c NUM        Print the last NUM bytes\n";
                std::cout << "  -f, --follow  Output appended data as the file grows\n";
                std::cout << "  -s NUM        Sleep for NUM seconds between follow iterations\n";
                std::cout << "  -q            Never print headers giving file names\n";
                std::cout << "  -v            Always print headers giving file names\n";
                std::cout << "  -NUM          Shorthand for -n NUM\n";
                std::cout << "      --help    Display this help and exit\n";
                return;
            }
            else if (arg == "-n" && i + 1 < args.size()) count = std::stoll(args[++i]);
            else if (arg == "-c" && i + 1 < args.size()) { count = std::stoll(args[++i]); useBytes = true; }
            else if (arg == "-f" || arg == "--follow") follow = true;
            else if (arg == "-q") quiet = true;
            else if (arg == "-v") verbose = true;
            else if (arg[0] == '-' && isdigit(arg[1])) count = std::abs(std::stoll(arg));
            else if (arg == "-s" && i + 1 < args.size()) sleepInterval = std::stoi(args[++i]) * 1000;
            else files.push_back(arg);
        }

        auto tailFile = [&](const std::string& path, bool showHeader) {
            std::ifstream file(path, std::ios::binary);
             if (!file) {
                 printError("tail: cannot open '" + path + "'");
                 return;
             }
             if (showHeader) std::cout << "==> " << path << " <==\n";

             if (useBytes) {
                 // Seek to end - count
                 file.seekg(0, std::ios::end);
                 long long fileSize = file.tellg();
                 long long startPos = (std::max)(0LL, fileSize - count);
                 file.seekg(startPos);
                 std::cout << file.rdbuf();
             } else {
                 // Efficient backwards reading for lines
                 file.seekg(0, std::ios::end);
                 long long fileSize = file.tellg();
                 if (fileSize == 0) return;

                 long long pos = fileSize;
                 long long linesFound = 0;
                 // Optimization: Reading from end
                 // Note: This is simpler than full buffer management but effective
                 // We step back 4KB at a time
                 const int CHUNK = 4096;
                 char buffer[CHUNK];
                 
                 // If file is small, just read it all
                 if (fileSize < CHUNK * 2 && count > 100) {
                     file.seekg(0);
                     // Fallback to forward read for small files/huge N
                     std::vector<std::string> buf;
                     std::string l;
                     while(std::getline(file, l)) {
                         buf.push_back(l);
                         if (buf.size() > count) buf.erase(buf.begin());
                     }
                     for(const auto& s : buf) std::cout << s << "\n";
                     return;
                 }

                 while (pos > 0 && linesFound <= count) {
                      long long toRead = (std::min)((long long)CHUNK, pos);
                      pos -= toRead;
                      file.seekg(pos);
                      file.read(buffer, toRead);
                      for (long long k = toRead - 1; k >= 0; --k) {
                          if (buffer[k] == '\n') {
                              linesFound++;
                              if (linesFound > count) {
                                  pos += k + 1; // Point to char after newline
                                  goto found_start;
                              }
                          }
                      }
                 }
                 pos = 0; // Read from start if we didn't find N newlines
                 
                 found_start:
                 file.seekg(pos);
                 // Dump from pos
                 std::cout << file.rdbuf(); 
                 // Note: rdbuf dumping might lose the last newline if not present? usually ok
             }
             if (showHeader) std::cout << "\n";

             if (follow) {
                 file.clear(); // Clear EOF
                 std::streampos lastPos = file.tellg();
                 while (ctx.running) {
                     // Check for new data
                     // In real implementation we should use generic filesystem watcher
                     // Polling here:
                     std::this_thread::sleep_for(std::chrono::milliseconds(sleepInterval));
                     fs::path p(path);
                     if (fs::exists(p) && fs::file_size(p) > lastPos) {
                         file.seekg(lastPos);
                         std::string line;
                         while (std::getline(file, line)) { // Or read block
                             std::cout << line << std::endl;
                         }
                         if (!file.eof()) {
                             // Block read might leave partial line? std::getline handles up to delim
                         }
                         file.clear();
                         lastPos = file.tellg();
                     } else if (fs::file_size(p) < lastPos) {
                         std::cerr << "tail: " << path << ": file truncated" << std::endl;
                         lastPos = 0;
                         file.seekg(0);
                     }
                 }
             }
        };

        if (files.empty() && !pipedInput.empty()) {
            // Cannot seek on pipe, must use buffer
            std::istringstream iss(pipedInput);
            std::deque<std::string> ring;
            if (useBytes) {
                // ... byte ring buffer is harder, just dump last N chars? 
                // String supports it
                if (pipedInput.size() > count) 
                    std::cout << pipedInput.substr(pipedInput.size() - count);
                else 
                    std::cout << pipedInput;
            } else {
                std::string line;
                while (std::getline(iss, line)) {
                    ring.push_back(line);
                    if (ring.size() > count) ring.pop_front();
                }
                for (const auto& l : ring) std::cout << l << "\n";
            }
        } else if (!files.empty()) {
            bool showHeader = (files.size() > 1 && !quiet) || verbose;
            for (const auto& f : files) {
                tailFile(resolvePath(f), showHeader);
                showHeader = (files.size() > 1);
            }
        } else {
            std::deque<std::string> ring;
            std::string line;
            while (std::getline(std::cin, line)) {
                ring.push_back(line);
                if (ring.size() > count) ring.pop_front();
            }
            for (const auto& l : ring) std::cout << l << "\n";
        }
    }

    // wc - print newline, word, and byte counts
    void cmdWc(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        bool lines = false, words = false, chars = false, bytes = false;
        bool maxLine = false;
        std::vector<std::string> files;

        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-l" || arg == "--lines") lines = true;
            else if (arg == "-w" || arg == "--words") words = true;
            else if (arg == "-m" || arg == "--chars") chars = true;
            else if (arg == "-c" || arg == "--bytes") bytes = true;
            else if (arg == "-L" || arg == "--max-line-length") maxLine = true;
            else files.push_back(arg);
        }

        if (!lines && !words && !chars && !bytes && !maxLine) {
            lines = words = bytes = true;
        }

        auto countFile = [&](std::istream& is, const std::string& name) {
             long long l = 0, w = 0, c = 0, b = 0, L = 0;
             long long currentL = 0;
             bool inWord = false;
             char buf[8192];
             
             // Optimized stream reading
             while (is.read(buf, sizeof(buf)) || is.gcount() > 0) {
                 size_t n = is.gcount();
                 b += n;

                 for (size_t i = 0; i < n; ++i) {
                     unsigned char ch = (unsigned char)buf[i];
                     if (ch == '\n') {
                         l++;
                         if (currentL > L) L = currentL;
                         currentL = 0;
                     } else {
                         // UTF-8 char counting logic
                         if (chars) {
                              // If using specific char count, skip continuation bytes
                              if ((ch & 0xC0) != 0x80) c++;
                         } else {
                              c++; 
                         }
                         if ((ch & 0xC0) != 0x80) currentL++;
                     }

                     if (isspace(ch)) {
                         inWord = false;
                     } else if (!inWord) {
                         inWord = true;
                         w++;
                     }
                 }
                 if (is.eof()) break;
             }
             if (currentL > L) L = currentL;

             if (lines) std::cout << std::setw(4) << l << " ";
             if (words) std::cout << std::setw(4) << w << " ";
             if (bytes) std::cout << std::setw(4) << b << " ";
             if (chars) std::cout << std::setw(4) << c << " ";
             if (maxLine) std::cout << std::setw(4) << L << " ";
             if (!name.empty()) std::cout << name;
             std::cout << std::endl;
             return std::make_tuple(l, w, b, c, L);
        };

        if (files.empty()) {
             std::istringstream iss(pipedInput);
             countFile(iss, "");
        } else {
             long long tl=0, tw=0, tb=0, tc=0, tL=0;
             for (const auto& file : files) {
                  std::ifstream ifs(resolvePath(file), std::ios::binary);
                  if (!ifs) {
                      printError("wc: " + file + ": No such file or directory");
                      continue;
                  }
                  auto [l, w, b, c, L] = countFile(ifs, file);
                  tl += l; tw += w; tb += b; tc += c; tL = (std::max)(tL, L);
             }
             if (files.size() > 1) {
                 if (lines) std::cout << std::setw(4) << tl << " ";
                 if (words) std::cout << std::setw(4) << tw << " ";
                 if (bytes) std::cout << std::setw(4) << tb << " ";
                 if (chars) std::cout << std::setw(4) << tc << " ";
                 if (maxLine) std::cout << std::setw(4) << tL << " ";
                 std::cout << "total" << std::endl;
             }
        }
    }

    // sort - sort lines of text files
    void cmdSort(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        bool reverse = false;
        bool numeric = false;
        bool unique = false;
        bool ignoreCase = false;
        bool check = false;
        int keyStart = 0; 
        int keyEnd = 0;
        std::vector<std::string> files;
        
        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-r" || arg == "--reverse") reverse = true;
            else if (arg == "-n" || arg == "--numeric-sort") numeric = true;
            else if (arg == "-u" || arg == "--unique") unique = true;
            else if (arg == "-f" || arg == "--ignore-case") ignoreCase = true;
            else if (arg == "-c" || arg == "--check") check = true;
            else if (arg == "-k" && i + 1 < args.size()) {
                std::string kdef = args[++i];
                size_t comma = kdef.find(',');
                if (comma != std::string::npos) {
                    keyStart = std::stoi(kdef.substr(0, comma));
                    keyEnd = std::stoi(kdef.substr(comma + 1));
                } else {
                    keyStart = std::stoi(kdef);
                    keyEnd = 0; 
                }
            }
            else if (arg[0] != '-') files.push_back(arg);
        }
        
        std::vector<std::string> lines;
        
        auto readLines = [&](std::istream& is) {
            std::string line;
            while (std::getline(is, line)) {
                lines.push_back(line);
            }
        };

        if (files.empty() && !pipedInput.empty()) {
            std::istringstream iss(pipedInput);
            readLines(iss);
        } else if (files.empty()) {
             printError("sort: missing file operand");
             return;
        } else {
             for (const auto& file : files) {
                 std::ifstream ifs(resolvePath(file));
                 if (!ifs) {
                     printError("sort: cannot open '" + file + "'");
                     return;
                 }
                 readLines(ifs);
             }
        }

        auto extractKey = [&](const std::string& s) {
            if (keyStart == 0) return s; 
            
            std::istringstream iss(s);
            std::string token;
            std::string keyStr;
            int col = 1;
            while (iss >> token) {
                if (col >= keyStart) {
                    if (!keyStr.empty()) keyStr += " ";
                    keyStr += token;
                }
                if (keyEnd > 0 && col >= keyEnd) break;
                col++;
            }
            return keyStr;
        };

        auto compare = [&](const std::string& a, const std::string& b) {
             std::string ka = extractKey(a);
             std::string kb = extractKey(b);

             if (numeric) {
                 try {
                     double da = std::stod(ka);
                     double db = std::stod(kb);
                     return da < db;
                 } catch (...) {
                     return ka < kb;
                 }
             }
             
             if (ignoreCase) {
                 std::transform(ka.begin(), ka.end(), ka.begin(), ::tolower);
                 std::transform(kb.begin(), kb.end(), kb.begin(), ::tolower);
             }
             
             return ka < kb;
        };

        if (check) {
            for (size_t i = 1; i < lines.size(); ++i) {
                bool ordered = !reverse ? !compare(lines[i], lines[i-1]) : !compare(lines[i-1], lines[i]);
                if (reverse) {
                    if (compare(lines[i-1], lines[i])) { 
                        std::cout << "sort: disorder: " << lines[i] << std::endl;
                        return;
                    }
                } else {
                     if (compare(lines[i], lines[i-1])) {
                         std::cout << "sort: disorder: " << lines[i] << std::endl;
                         return;
                     }
                }
            }
            return;
        }

        std::sort(lines.begin(), lines.end(), compare);

        if (reverse) {
            std::reverse(lines.begin(), lines.end());
        }
        
        if (unique) {
            auto last = std::unique(lines.begin(), lines.end(), [&](const std::string& a, const std::string& b){
                 std::string ka = extractKey(a);
                 std::string kb = extractKey(b);
                 if (ignoreCase) {
                      std::transform(ka.begin(), ka.end(), ka.begin(), ::tolower);
                      std::transform(kb.begin(), kb.end(), kb.begin(), ::tolower);
                 }
                 return ka == kb;
            });
            lines.erase(last, lines.end());
        }
        
        for (const auto& line : lines) {
            std::cout << line << std::endl;
        }
    }

    // uniq - report or omit repeated lines
    void cmdUniq(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        bool countDupes = false;
        bool onlyDupes = false; 
        bool onlyUnique = false; 
        bool ignoreCase = false;
        int skipFields = 0;
        int skipChars = 0;
        std::vector<std::string> files;
        
        for (size_t i = 1; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-c" || arg == "--count") countDupes = true;
            else if (arg == "-d" || arg == "--repeated") onlyDupes = true;
            else if (arg == "-u" || arg == "--unique") onlyUnique = true;
            else if (arg == "-i" || arg == "--ignore-case") ignoreCase = true;
            else if (arg.rfind("-f", 0) == 0) skipFields = std::stoi(arg.length() > 2 ? arg.substr(2) : args[++i]);
            else if (arg.rfind("-s", 0) == 0) skipChars = std::stoi(arg.length() > 2 ? arg.substr(2) : args[++i]);
            else if (arg[0] != '-') files.push_back(arg);
        }
        
        std::unique_ptr<std::istream> inputPtr;
        std::ifstream fileStream;
        
        if (!pipedInput.empty()) {
             inputPtr = std::make_unique<std::istringstream>(pipedInput);
        } else if (!files.empty()) {
             fileStream.open(resolvePath(files[0])); 
             if (!fileStream) {
                 printError("uniq: cannot open '" + files[0] + "'");
                 return;
             }
        } else {
             printError("uniq: missing file operand");
             return;
        }
        
        std::istream& is = (!pipedInput.empty()) ? (std::istream&)*inputPtr : fileStream;
        
        std::ostream* os = &std::cout;
        std::ofstream outStream;
        if (files.size() > 1) {
             outStream.open(resolvePath(files[1]));
             if (outStream) os = &outStream;
        }

        std::string prevLine;
        std::string currentLine;
        int count = 0;
        bool first = true;

        auto linesMatch = [&](const std::string& a, const std::string& b) {
            std::string sa = a;
            std::string sb = b;
            
            if (skipFields > 0) {
                 int skipped = 0;
                 size_t posA = 0, posB = 0;
                 while (skipped < skipFields) {
                     while (posA < sa.length() && !isspace((unsigned char)sa[posA])) posA++;
                     while (posA < sa.length() && isspace((unsigned char)sa[posA])) posA++;
                     while (posB < sb.length() && !isspace((unsigned char)sb[posB])) posB++;
                     while (posB < sb.length() && isspace((unsigned char)sb[posB])) posB++;
                     skipped++;
                 }
                 if (posA < sa.length()) sa = sa.substr(posA); else sa = "";
                 if (posB < sb.length()) sb = sb.substr(posB); else sb = "";
            }
            
            if (skipChars > 0 && sa.length() > (size_t)skipChars) sa = sa.substr(skipChars);
            if (skipChars > 0 && sb.length() > (size_t)skipChars) sb = sb.substr(skipChars);
            
            if (ignoreCase) {
                std::transform(sa.begin(), sa.end(), sa.begin(), ::tolower);
                std::transform(sb.begin(), sb.end(), sb.begin(), ::tolower);
            }
            return sa == sb;
        };

        auto flush = [&](const std::string& line, int cnt) {
             if (cnt == 0) return;
             bool print = true;
             if (onlyDupes && cnt == 1) print = false;
             if (onlyUnique && cnt > 1) print = false;
             
             if (print) {
                 if (countDupes) *os << std::setw(7) << cnt << " ";
                 *os << line << std::endl;
             }
        };

        while (std::getline(is, currentLine)) {
            if (first) {
                prevLine = currentLine;
                count = 1;
                first = false;
                continue;
            }
            
            if (linesMatch(prevLine, currentLine)) {
                count++;
            } else {
                flush(prevLine, count);
                prevLine = currentLine;
                count = 1;
            }
        }
        if (!first) flush(prevLine, count);
    }

    // find - search for files in a directory hierarchy
    void cmdFind(const std::vector<std::string>& args) {
        std::vector<std::string> paths;
        std::string namePattern;
        std::string typeFilter; 
        long long sizeMin = -1, sizeMax = -1;
        int maxDepth = -1;
        bool exec = false;
        std::vector<std::string> execCommand;

        size_t i = 1;
        while (i < args.size() && args[i][0] != '-') {
            paths.push_back(args[i++]);
        }
        if (paths.empty()) paths.push_back(".");

        for (; i < args.size(); ++i) {
            std::string arg = args[i];
            if (arg == "-name" && i + 1 < args.size()) namePattern = args[++i];
            else if (arg == "-type" && i + 1 < args.size()) typeFilter = args[++i];
            else if (arg == "-size" && i + 1 < args.size()) {
                std::string s = args[++i];
                bool gt = (s[0] == '+');
                bool lt = (s[0] == '-');
                if (gt || lt) s = s.substr(1);
                long long val = 0;
                try { 
                     size_t suffixPos = 0;
                     val = std::stoll(s, &suffixPos);
                     if (suffixPos < s.length()) {
                         char suf = s[suffixPos];
                         if (suf == 'k' || suf == 'K') val *= 1024;
                         else if (suf == 'M') val *= 1024*1024;
                         else if (suf == 'G') val *= 1024*1024*1024;
                     }
                } catch(...) {}
                
                if (gt) sizeMin = val + 1;
                else if (lt) sizeMax = val - 1;
                else { sizeMin = val; sizeMax = val; } 
            }
            else if (arg == "-maxdepth" && i + 1 < args.size()) maxDepth = std::stoi(args[++i]);
            else if (arg == "-exec") {
                exec = true;
                i++;
                while (i < args.size()) {
                    if (args[i] == ";") break;
                    execCommand.push_back(args[i]);
                    i++;
                }
            }
        }

        for (const auto& path : paths) {
            std::string root = resolvePath(path);
            if (!fs::exists(root)) {
                printError("find: '" + path + "': No such file or directory");
                continue;
            }

            try {
                auto walker = [&](auto&& self, const fs::path& p, int depth) -> void {
                    if (maxDepth != -1 && depth > maxDepth) return;
                    
                    bool match = true;
                    std::string filename = p.filename().string();
                    
                    if (!namePattern.empty()) {
                         if (namePattern.front() == '*' && namePattern.back() == '*') {
                             std::string sub = namePattern.substr(1, namePattern.length()-2);
                             if (filename.find(sub) == std::string::npos) match = false;
                         } else if (namePattern.front() == '*') {
                             std::string suf = namePattern.substr(1);
                             if (filename.length() < suf.length() || filename.substr(filename.length()-suf.length()) != suf) match=false;
                         } else if (namePattern.back() == '*') {
                             std::string pre = namePattern.substr(0, namePattern.length()-1);
                             if (filename.substr(0, pre.length()) != pre) match=false;
                         } else {
                             if (filename != namePattern) match = false;
                         }
                    }

                    if (match && !typeFilter.empty()) {
                        if (typeFilter == "f" && !fs::is_regular_file(p)) match = false;
                        else if (typeFilter == "d" && !fs::is_directory(p)) match = false;
                    }

                    if (match && (sizeMin != -1 || sizeMax != -1)) {
                         if (fs::is_regular_file(p)) {
                             uintmax_t sz = fs::file_size(p);
                             if (sizeMin != -1 && sz < (uintmax_t)sizeMin) match = false;
                             if (sizeMax != -1 && sz > (uintmax_t)sizeMax) match = false;
                         } else {
                             match = false;
                         }
                    }

                    if (match) {
                        if (exec) {
                            std::string cmd;
                            for (const auto& part : execCommand) {
                                if (part == "{}") cmd += "\"" + p.string() + "\" ";
                                else cmd += part + " ";
                            }
                            runProcess(cmd);
                        } else {
                            std::cout << p.string() << std::endl;
                        }
                    }

                    if (fs::is_directory(p)) {
                        for (const auto& entry : fs::directory_iterator(p)) {
                             self(self, entry.path(), depth + 1);
                        }
                    }
                };
                
                walker(walker, root, 0);

            } catch (const std::exception& e) {
                printError("find: " + std::string(e.what()));
            }
        }
    }

    // ============================================================================
    // TEXT PROCESSING COMMANDS
    // ============================================================================

    // less/more - pager for viewing files
    void cmdLess(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        std::vector<std::string> lines;
        
        if (!pipedInput.empty()) {
            std::istringstream iss(pipedInput);
            std::string line;
            while (std::getline(iss, line)) {
                lines.push_back(line);
            }
        } else if (args.size() > 1) {
            std::string filePath = resolvePath(args[1]);
            std::ifstream file(filePath);
            if (!file) {
                printError("less: cannot open '" + args[1] + "'");
                return;
            }
            std::string line;
            while (std::getline(file, line)) {
                lines.push_back(line);
            }
        } else {
            printError("less: missing file operand");
            return;
        }
        
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        CONSOLE_SCREEN_BUFFER_INFO csbi;
        GetConsoleScreenBufferInfo(hConsole, &csbi);
        int pageSize = csbi.srWindow.Bottom - csbi.srWindow.Top - 1;
        if (pageSize < 5) pageSize = 20;
        
        size_t currentLine = 0;
        HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
        DWORD oldMode;
        GetConsoleMode(hInput, &oldMode);
        SetConsoleMode(hInput, 0);  // Raw input mode
        
        while (currentLine < lines.size()) {
            // Display a page
            for (int i = 0; i < pageSize && currentLine < lines.size(); ++i, ++currentLine) {
                std::cout << lines[currentLine] << "\n";
            }
            
            if (currentLine >= lines.size()) break;
            
            // Show prompt
            SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY);
            std::cout << "-- More -- (q to quit, Enter for next line, Space for next page)";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            
            // Wait for key
            INPUT_RECORD ir;
            DWORD read;
            while (true) {
                ReadConsoleInput(hInput, &ir, 1, &read);
                if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown) {
                    char ch = ir.Event.KeyEvent.uChar.AsciiChar;
                    if (ch == 'q' || ch == 'Q') {
                        std::cout << "\r                                                            \r";
                        SetConsoleMode(hInput, oldMode);
                        return;
                    } else if (ch == ' ') {
                        std::cout << "\r                                                            \r";
                        break;  // Next page
                    } else if (ch == '\r' || ch == '\n') {
                        std::cout << "\r                                                            \r";
                        currentLine--;  // Show one more line
                        break;
                    }
                }
            }
        }
        
        SetConsoleMode(hInput, oldMode);
    }

    void cmdCut(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        char delimiter = '\t';
        std::string outputDelimiter;
        bool outputDelimiterSet = false;
        std::vector<std::pair<int, int>> ranges;
        std::vector<std::string> files;
        bool byByte = false;
        bool byChar = false;
        bool byField = false;
        bool complement = false;
        bool onlyDelimited = false;
        
        auto parseRange = [&](const std::string& spec) {
            std::istringstream ss(spec);
            std::string part;
            while (std::getline(ss, part, ',')) {
                size_t dashPos = part.find('-');
                if (dashPos == std::string::npos) {
                    int val = std::stoi(part);
                    ranges.push_back({val, val});
                } else if (dashPos == 0) {
                    int end = std::stoi(part.substr(1));
                    ranges.push_back({1, end});
                } else if (dashPos == part.length() - 1) {
                    int start = std::stoi(part.substr(0, dashPos));
                    ranges.push_back({start, INT_MAX});
                } else {
                    int start = std::stoi(part.substr(0, dashPos));
                    int end = std::stoi(part.substr(dashPos + 1));
                    ranges.push_back({start, end});
                }
            }
        };
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-d" && i + 1 < args.size()) {
                std::string delim = args[++i];
                if (!delim.empty()) delimiter = delim[0];
            } else if (args[i].substr(0, 2) == "-d" && args[i].length() > 2) {
                delimiter = args[i][2];
            } else if (args[i] == "-f" && i + 1 < args.size()) {
                byField = true;
                parseRange(args[++i]);
            } else if (args[i].substr(0, 2) == "-f" && args[i].length() > 2) {
                byField = true;
                parseRange(args[i].substr(2));
            } else if (args[i] == "-c" && i + 1 < args.size()) {
                byChar = true;
                parseRange(args[++i]);
            } else if (args[i].substr(0, 2) == "-c" && args[i].length() > 2) {
                byChar = true;
                parseRange(args[i].substr(2));
            } else if (args[i] == "-b" && i + 1 < args.size()) {
                byByte = true;
                parseRange(args[++i]);
            } else if (args[i].substr(0, 2) == "-b" && args[i].length() > 2) {
                byByte = true;
                parseRange(args[i].substr(2));
            } else if (args[i] == "--complement") {
                complement = true;
            } else if (args[i] == "-s" || args[i] == "--only-delimited") {
                onlyDelimited = true;
            } else if (args[i] == "--output-delimiter" && i + 1 < args.size()) {
                outputDelimiter = args[++i];
                outputDelimiterSet = true;
            } else if (args[i].substr(0, 19) == "--output-delimiter=") {
                outputDelimiter = args[i].substr(19);
                outputDelimiterSet = true;
            } else if (args[i][0] != '-') {
                files.push_back(args[i]);
            }
        }
        
        if (ranges.empty()) {
            printError("cut: you must specify a list of bytes, characters, or fields");
            return;
        }

        if (!outputDelimiterSet) {
            outputDelimiter = std::string(1, delimiter);
        }

        std::sort(ranges.begin(), ranges.end());

        auto isInRange = [&](int pos) -> bool {
            for (const auto& r : ranges) {
                if (pos >= r.first && pos <= r.second) return !complement;
            }
            return complement;
        };

        auto processLine = [&](const std::string& line) {
            if (byByte || byChar) {
                std::string result;
                bool first = true;
                for (int pos = 1; pos <= (int)line.length(); ++pos) {
                    if (isInRange(pos)) {
                        if (!first && outputDelimiterSet) result += outputDelimiter;
                        result += line[pos - 1];
                        first = false;
                    }
                }
                std::cout << result << "\n";
            } else {
                if (onlyDelimited && line.find(delimiter) == std::string::npos) {
                    return;
                }
                
                std::vector<std::string> tokens;
                size_t start = 0, end;
                while ((end = line.find(delimiter, start)) != std::string::npos) {
                    tokens.push_back(line.substr(start, end - start));
                    start = end + 1;
                }
                tokens.push_back(line.substr(start));
                
                std::string result;
                bool first = true;
                for (int pos = 1; pos <= (int)tokens.size(); ++pos) {
                    if (isInRange(pos)) {
                        if (!first) result += outputDelimiter;
                        result += tokens[pos - 1];
                        first = false;
                    }
                }
                std::cout << result << "\n";
            }
        };

        if (!pipedInput.empty()) {
            std::istringstream iss(pipedInput);
            std::string line;
            while (std::getline(iss, line)) {
                processLine(line);
            }
        } else if (!files.empty()) {
            for (const auto& filePath : files) {
                std::ifstream file(resolvePath(filePath));
                if (!file) {
                    printError("cut: cannot open '" + filePath + "'");
                    continue;
                }
                std::string line;
                while (std::getline(file, line)) {
                    processLine(line);
                }
            }
        } else {
            std::string line;
            while (std::getline(std::cin, line)) {
                processLine(line);
            }
        }
    }

    void cmdTr(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        bool deleteMode = false;
        bool squeezeMode = false;
        bool complementMode = false;
        std::string set1, set2;
        
        size_t argIdx = 1;
        while (argIdx < args.size() && args[argIdx][0] == '-' && args[argIdx].length() > 1) {
            for (size_t k = 1; k < args[argIdx].length(); ++k) {
                char flag = args[argIdx][k];
                if (flag == 'd') deleteMode = true;
                else if (flag == 's') squeezeMode = true;
                else if (flag == 'c' || flag == 'C') complementMode = true;
            }
            argIdx++;
        }
        
        if (argIdx < args.size()) set1 = args[argIdx++];
        if (argIdx < args.size()) set2 = args[argIdx++];
        
        if (set1.empty()) {
            printError("tr: missing operand");
            return;
        }

        auto expandClass = [](const std::string& className) -> std::string {
            std::string result;
            if (className == "alpha" || className == "ALPHA") {
                for (char c = 'a'; c <= 'z'; ++c) result += c;
                for (char c = 'A'; c <= 'Z'; ++c) result += c;
            } else if (className == "digit" || className == "DIGIT") {
                for (char c = '0'; c <= '9'; ++c) result += c;
            } else if (className == "upper" || className == "UPPER") {
                for (char c = 'A'; c <= 'Z'; ++c) result += c;
            } else if (className == "lower" || className == "LOWER") {
                for (char c = 'a'; c <= 'z'; ++c) result += c;
            } else if (className == "alnum" || className == "ALNUM") {
                for (char c = 'a'; c <= 'z'; ++c) result += c;
                for (char c = 'A'; c <= 'Z'; ++c) result += c;
                for (char c = '0'; c <= '9'; ++c) result += c;
            } else if (className == "space" || className == "SPACE") {
                result = " \t\n\r\v\f";
            } else if (className == "blank" || className == "BLANK") {
                result = " \t";
            } else if (className == "punct" || className == "PUNCT") {
                result = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
            } else if (className == "xdigit" || className == "XDIGIT") {
                for (char c = '0'; c <= '9'; ++c) result += c;
                for (char c = 'a'; c <= 'f'; ++c) result += c;
                for (char c = 'A'; c <= 'F'; ++c) result += c;
            } else if (className == "cntrl" || className == "CNTRL") {
                for (char c = 0; c < 32; ++c) result += c;
                result += (char)127;
            } else if (className == "graph" || className == "GRAPH") {
                for (char c = 33; c < 127; ++c) result += c;
            } else if (className == "print" || className == "PRINT") {
                for (char c = 32; c < 127; ++c) result += c;
            }
            return result;
        };

        auto expandEscape = [](char c) -> char {
            switch (c) {
                case 'n': return '\n';
                case 't': return '\t';
                case 'r': return '\r';
                case 'f': return '\f';
                case 'v': return '\v';
                case 'a': return '\a';
                case 'b': return '\b';
                case '\\': return '\\';
                default: return c;
            }
        };

        auto expandSet = [&](const std::string& set) -> std::string {
            std::string result;
            for (size_t i = 0; i < set.length(); ++i) {
                if (set[i] == '[' && i + 2 < set.length() && set[i + 1] == ':') {
                    size_t endPos = set.find(":]", i + 2);
                    if (endPos != std::string::npos) {
                        std::string className = set.substr(i + 2, endPos - i - 2);
                        result += expandClass(className);
                        i = endPos + 1;
                        continue;
                    }
                }
                if (set[i] == '\\' && i + 1 < set.length()) {
                    char next = set[i + 1];
                    if (next >= '0' && next <= '7') {
                        int val = 0;
                        size_t j = i + 1;
                        while (j < set.length() && j < i + 4 && set[j] >= '0' && set[j] <= '7') {
                            val = val * 8 + (set[j] - '0');
                            j++;
                        }
                        result += (char)val;
                        i = j - 1;
                    } else {
                        result += expandEscape(next);
                        i++;
                    }
                    continue;
                }
                if (i + 2 < set.length() && set[i + 1] == '-') {
                    char start = set[i];
                    char end = set[i + 2];
                    if (start <= end) {
                        for (char c = start; c <= end; ++c) result += c;
                    } else {
                        for (char c = start; c >= end; --c) result += c;
                    }
                    i += 2;
                } else {
                    result += set[i];
                }
            }
            return result;
        };
        
        std::string expandedSet1 = expandSet(set1);
        std::string expandedSet2 = expandSet(set2);
        
        if (complementMode) {
            std::string complement;
            for (int c = 1; c < 256; ++c) {
                if (expandedSet1.find((char)c) == std::string::npos) {
                    complement += (char)c;
                }
            }
            expandedSet1 = complement;
        }
        
        while (!deleteMode && !expandedSet2.empty() && expandedSet2.length() < expandedSet1.length()) {
            expandedSet2 += expandedSet2.back();
        }
        
        std::string input = pipedInput;
        if (input.empty()) {
            std::ostringstream oss;
            char buf[4096];
            while (std::cin.read(buf, sizeof(buf)) || std::cin.gcount() > 0) {
                oss.write(buf, std::cin.gcount());
            }
            input = oss.str();
        }
        
        std::string result;
        char lastChar = '\0';
        bool lastWasInSet1 = false;
        
        for (unsigned char c : input) {
            size_t pos = expandedSet1.find(c);
            if (deleteMode) {
                if (pos == std::string::npos) {
                    if (!squeezeMode || c != lastChar) {
                        result += c;
                        lastChar = c;
                    }
                }
            } else if (pos != std::string::npos) {
                char newChar = (pos < expandedSet2.length()) ? expandedSet2[pos] : c;
                if (!squeezeMode || newChar != lastChar || !lastWasInSet1) {
                    result += newChar;
                    lastChar = newChar;
                }
                lastWasInSet1 = true;
            } else {
                result += c;
                lastChar = c;
                lastWasInSet1 = false;
            }
        }
        
        std::cout << result;
    }

    void cmdSed(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        if (args.size() < 2) {
            printError("sed: missing script");
            return;
        }
        
        std::vector<std::string> scripts;
        std::vector<std::string> files;
        bool inPlace = false;
        std::string inPlaceSuffix;
        bool quietMode = false;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-n" || args[i] == "--quiet" || args[i] == "--silent") {
                quietMode = true;
            } else if (args[i] == "-e" && i + 1 < args.size()) {
                scripts.push_back(args[++i]);
            } else if (args[i] == "-i" || args[i].substr(0, 2) == "-i") {
                inPlace = true;
                if (args[i].length() > 2) inPlaceSuffix = args[i].substr(2);
            } else if (args[i][0] == '-') {
            } else if (scripts.empty()) {
                scripts.push_back(args[i]);
            } else {
                files.push_back(args[i]);
            }
        }
        
        if (scripts.empty()) {
            printError("sed: missing script");
            return;
        }

        struct SedCommand {
            std::string addr1;
            std::string addr2;
            char cmd;
            std::string arg1;
            std::string arg2;
            bool globalFlag;
            bool printFlag;
        };

        auto parseScript = [&](const std::string& script) -> std::vector<SedCommand> {
            std::vector<SedCommand> commands;
            size_t pos = 0;
            
            while (pos < script.length()) {
                while (pos < script.length() && (script[pos] == ' ' || script[pos] == '\t' || script[pos] == ';')) pos++;
                if (pos >= script.length()) break;
                
                SedCommand cmd = {"", "", '\0', "", "", false, false};
                
                if (std::isdigit(script[pos]) || script[pos] == '$') {
                    while (pos < script.length() && (std::isdigit(script[pos]) || script[pos] == '$')) {
                        cmd.addr1 += script[pos++];
                    }
                    if (pos < script.length() && script[pos] == ',') {
                        pos++;
                        while (pos < script.length() && (std::isdigit(script[pos]) || script[pos] == '$')) {
                            cmd.addr2 += script[pos++];
                        }
                    }
                } else if (script[pos] == '/') {
                    pos++;
                    while (pos < script.length() && script[pos] != '/') {
                        if (script[pos] == '\\' && pos + 1 < script.length()) {
                            cmd.addr1 += script[pos++];
                        }
                        cmd.addr1 += script[pos++];
                    }
                    if (pos < script.length()) pos++;
                }
                
                while (pos < script.length() && (script[pos] == ' ' || script[pos] == '\t')) pos++;
                if (pos >= script.length()) break;
                
                cmd.cmd = script[pos++];
                
                if (cmd.cmd == 's' && pos < script.length()) {
                    char delim = script[pos++];
                    bool escaped = false;
                    while (pos < script.length()) {
                        if (escaped) {
                            cmd.arg1 += script[pos++];
                            escaped = false;
                        } else if (script[pos] == '\\') {
                            escaped = true;
                            cmd.arg1 += script[pos++];
                        } else if (script[pos] == delim) {
                            pos++;
                            break;
                        } else {
                            cmd.arg1 += script[pos++];
                        }
                    }
                    escaped = false;
                    while (pos < script.length()) {
                        if (escaped) {
                            cmd.arg2 += script[pos++];
                            escaped = false;
                        } else if (script[pos] == '\\') {
                            escaped = true;
                            cmd.arg2 += script[pos++];
                        } else if (script[pos] == delim) {
                            pos++;
                            break;
                        } else {
                            cmd.arg2 += script[pos++];
                        }
                    }
                    while (pos < script.length() && script[pos] != ';' && script[pos] != '\n') {
                        if (script[pos] == 'g') cmd.globalFlag = true;
                        else if (script[pos] == 'p') cmd.printFlag = true;
                        pos++;
                    }
                } else if (cmd.cmd == 'y' && pos < script.length()) {
                    char delim = script[pos++];
                    while (pos < script.length() && script[pos] != delim) cmd.arg1 += script[pos++];
                    if (pos < script.length()) pos++;
                    while (pos < script.length() && script[pos] != delim) cmd.arg2 += script[pos++];
                    if (pos < script.length()) pos++;
                }
                
                commands.push_back(cmd);
            }
            return commands;
        };

        std::vector<SedCommand> allCommands;
        for (const auto& script : scripts) {
            auto cmds = parseScript(script);
            allCommands.insert(allCommands.end(), cmds.begin(), cmds.end());
        }

        auto matchAddress = [](const std::string& addr, int lineNum, int lastLine, const std::string& line) -> bool {
            if (addr.empty()) return true;
            if (addr == "$") return lineNum == lastLine;
            if (std::isdigit(addr[0])) return lineNum == std::stoi(addr);
            try {
                std::regex re(addr);
                return std::regex_search(line, re);
            } catch (...) {
                return line.find(addr) != std::string::npos;
            }
        };

        auto processLines = [&](std::vector<std::string>& lines) -> std::string {
            std::ostringstream output;
            int lastLine = (int)lines.size();
            std::map<int, bool> inRange;
            
            for (int lineNum = 1; lineNum <= (int)lines.size(); ++lineNum) {
                std::string line = lines[lineNum - 1];
                bool deleted = false;
                bool printed = false;
                
                for (size_t ci = 0; ci < allCommands.size(); ++ci) {
                    const auto& cmd = allCommands[ci];
                    
                    bool inAddr = false;
                    if (cmd.addr1.empty() && cmd.addr2.empty()) {
                        inAddr = true;
                    } else if (cmd.addr2.empty()) {
                        inAddr = matchAddress(cmd.addr1, lineNum, lastLine, line);
                    } else {
                        if (!inRange[ci] && matchAddress(cmd.addr1, lineNum, lastLine, line)) {
                            inRange[ci] = true;
                        }
                        if (inRange[ci]) {
                            inAddr = true;
                            if (matchAddress(cmd.addr2, lineNum, lastLine, line)) {
                                inRange[ci] = false;
                            }
                        }
                    }
                    
                    if (!inAddr) continue;
                    
                    switch (cmd.cmd) {
                        case 'd':
                            deleted = true;
                            break;
                        case 'p':
                            output << line << "\n";
                            printed = true;
                            break;
                        case 'q':
                            if (!quietMode && !deleted) output << line << "\n";
                            return output.str();
                        case 's': {
                            try {
                                std::regex re(cmd.arg1);
                                std::string repl = cmd.arg2;
                                if (cmd.globalFlag) {
                                    line = std::regex_replace(line, re, repl);
                                } else {
                                    line = std::regex_replace(line, re, repl, std::regex_constants::format_first_only);
                                }
                                if (cmd.printFlag) {
                                    output << line << "\n";
                                    printed = true;
                                }
                            } catch (...) {
                                if (cmd.globalFlag) {
                                    size_t pos = 0;
                                    while ((pos = line.find(cmd.arg1, pos)) != std::string::npos) {
                                        line.replace(pos, cmd.arg1.length(), cmd.arg2);
                                        pos += cmd.arg2.length();
                                    }
                                } else {
                                    size_t pos = line.find(cmd.arg1);
                                    if (pos != std::string::npos) {
                                        line.replace(pos, cmd.arg1.length(), cmd.arg2);
                                    }
                                }
                            }
                            break;
                        }
                        case 'y': {
                            for (char& c : line) {
                                size_t idx = cmd.arg1.find(c);
                                if (idx != std::string::npos && idx < cmd.arg2.length()) {
                                    c = cmd.arg2[idx];
                                }
                            }
                            break;
                        }
                    }
                    
                    if (deleted) break;
                }
                
                if (!deleted && !quietMode) {
                    output << line << "\n";
                }
            }
            return output.str();
        };

        if (!pipedInput.empty()) {
            std::vector<std::string> lines;
            std::istringstream iss(pipedInput);
            std::string line;
            while (std::getline(iss, line)) lines.push_back(line);
            std::cout << processLines(lines);
        } else if (!files.empty()) {
            for (const auto& filePath : files) {
                std::vector<std::string> lines;
                std::ifstream file(resolvePath(filePath));
                if (!file) {
                    printError("sed: cannot open '" + filePath + "'");
                    continue;
                }
                std::string line;
                while (std::getline(file, line)) lines.push_back(line);
                file.close();
                
                std::string result = processLines(lines);
                
                if (inPlace) {
                    if (!inPlaceSuffix.empty()) {
                        fs::copy_file(resolvePath(filePath), resolvePath(filePath) + inPlaceSuffix, fs::copy_options::overwrite_existing);
                    }
                    std::ofstream out(resolvePath(filePath));
                    out << result;
                } else {
                    std::cout << result;
                }
            }
        } else {
            std::vector<std::string> lines;
            std::string line;
            while (std::getline(std::cin, line)) lines.push_back(line);
            std::cout << processLines(lines);
        }
    }

    void cmdAwk(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        if (args.size() < 2) {
            printError("awk: missing program");
            return;
        }
        
        std::string fieldSepStr = " ";
        std::string program;
        std::vector<std::string> files;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-F" && i + 1 < args.size()) {
                fieldSepStr = args[++i];
            } else if (args[i].substr(0, 2) == "-F") {
                fieldSepStr = args[i].substr(2);
            } else if (program.empty() && (args[i][0] == '{' || args[i][0] == '\'')) {
                program = args[i];
            } else if (program.empty() && args[i][0] != '-') {
                program = args[i];
            } else if (args[i][0] != '-') {
                files.push_back(args[i]);
            }
        }

        std::map<std::string, std::string> vars;
        vars["FS"] = fieldSepStr;
        vars["OFS"] = " ";
        vars["ORS"] = "\n";
        vars["NR"] = "0";
        vars["NF"] = "0";
        vars["FILENAME"] = "";

        auto splitFields = [&](const std::string& line) -> std::vector<std::string> {
            std::vector<std::string> fields;
            fields.push_back(line);
            std::string fs = vars["FS"];
            
            if (fs == " ") {
                std::string token;
                bool inToken = false;
                for (char c : line) {
                    if (std::isspace(c)) {
                        if (inToken) {
                            fields.push_back(token);
                            token.clear();
                            inToken = false;
                        }
                    } else {
                        token += c;
                        inToken = true;
                    }
                }
                if (inToken) fields.push_back(token);
            } else if (fs.length() == 1) {
                std::istringstream iss(line);
                std::string token;
                while (std::getline(iss, token, fs[0])) {
                    fields.push_back(token);
                }
            } else {
                size_t pos = 0, found;
                while ((found = line.find(fs, pos)) != std::string::npos) {
                    fields.push_back(line.substr(pos, found - pos));
                    pos = found + fs.length();
                }
                fields.push_back(line.substr(pos));
            }
            
            vars["NF"] = std::to_string(fields.size() - 1);
            return fields;
        };

        auto evalExpr = [&](const std::string& expr, const std::vector<std::string>& fields) -> std::string {
            std::string result = expr;
            
            for (int i = 9; i >= 0; --i) {
                std::string placeholder = "$" + std::to_string(i);
                size_t pos;
                while ((pos = result.find(placeholder)) != std::string::npos) {
                    std::string val = (i < (int)fields.size()) ? fields[i] : "";
                    result.replace(pos, placeholder.length(), val);
                }
            }
            
            for (const auto& kv : vars) {
                size_t pos;
                while ((pos = result.find(kv.first)) != std::string::npos) {
                    bool validBoundary = true;
                    if (pos > 0 && (std::isalnum(result[pos - 1]) || result[pos - 1] == '_')) validBoundary = false;
                    size_t endPos = pos + kv.first.length();
                    if (endPos < result.length() && (std::isalnum(result[endPos]) || result[endPos] == '_')) validBoundary = false;
                    if (validBoundary) {
                        result.replace(pos, kv.first.length(), kv.second);
                    } else {
                        break;
                    }
                }
            }
            
            size_t lenPos;
            while ((lenPos = result.find("length(")) != std::string::npos) {
                size_t endParen = result.find(")", lenPos);
                if (endParen != std::string::npos) {
                    std::string arg = result.substr(lenPos + 7, endParen - lenPos - 7);
                    result.replace(lenPos, endParen - lenPos + 1, std::to_string(arg.length()));
                } else break;
            }
            
            while ((lenPos = result.find("toupper(")) != std::string::npos) {
                size_t endParen = result.find(")", lenPos);
                if (endParen != std::string::npos) {
                    std::string arg = result.substr(lenPos + 8, endParen - lenPos - 8);
                    std::transform(arg.begin(), arg.end(), arg.begin(), ::toupper);
                    result.replace(lenPos, endParen - lenPos + 1, arg);
                } else break;
            }
            
            while ((lenPos = result.find("tolower(")) != std::string::npos) {
                size_t endParen = result.find(")", lenPos);
                if (endParen != std::string::npos) {
                    std::string arg = result.substr(lenPos + 8, endParen - lenPos - 8);
                    std::transform(arg.begin(), arg.end(), arg.begin(), ::tolower);
                    result.replace(lenPos, endParen - lenPos + 1, arg);
                } else break;
            }
            
            return result;
        };

        auto parseAction = [&](const std::string& action, const std::vector<std::string>& fields) {
            std::string act = action;
            while (!act.empty() && (act.front() == '{' || act.front() == ' ')) act.erase(0, 1);
            while (!act.empty() && (act.back() == '}' || act.back() == ' ')) act.pop_back();
            
            std::istringstream iss(act);
            std::string stmt;
            while (std::getline(iss, stmt, ';')) {
                while (!stmt.empty() && stmt.front() == ' ') stmt.erase(0, 1);
                while (!stmt.empty() && stmt.back() == ' ') stmt.pop_back();
                if (stmt.empty()) continue;
                
                if (stmt.substr(0, 5) == "print") {
                    std::string printArgs = stmt.substr(5);
                    while (!printArgs.empty() && printArgs.front() == ' ') printArgs.erase(0, 1);
                    
                    if (printArgs.empty()) {
                        std::cout << fields[0] << vars["ORS"];
                    } else {
                        std::vector<std::string> parts;
                        std::string current;
                        bool inQuote = false;
                        for (size_t i = 0; i < printArgs.length(); ++i) {
                            char c = printArgs[i];
                            if (c == '"') {
                                inQuote = !inQuote;
                            } else if ((c == ',' || c == ' ') && !inQuote) {
                                if (!current.empty()) {
                                    parts.push_back(current);
                                    current.clear();
                                }
                            } else {
                                current += c;
                            }
                        }
                        if (!current.empty()) parts.push_back(current);
                        
                        std::string output;
                        for (size_t i = 0; i < parts.size(); ++i) {
                            if (i > 0) output += vars["OFS"];
                            output += evalExpr(parts[i], fields);
                        }
                        std::cout << output << vars["ORS"];
                    }
                } else if (stmt.substr(0, 6) == "printf") {
                    std::string printfArgs = stmt.substr(6);
                    while (!printfArgs.empty() && printfArgs.front() == ' ') printfArgs.erase(0, 1);
                    
                    size_t firstQuote = printfArgs.find('"');
                    size_t lastQuote = printfArgs.rfind('"');
                    if (firstQuote != std::string::npos && lastQuote > firstQuote) {
                        std::string fmt = printfArgs.substr(firstQuote + 1, lastQuote - firstQuote - 1);
                        std::string argsStr = printfArgs.substr(lastQuote + 1);
                        
                        std::vector<std::string> printfVals;
                        std::istringstream argStream(argsStr);
                        std::string arg;
                        while (std::getline(argStream, arg, ',')) {
                            while (!arg.empty() && arg.front() == ' ') arg.erase(0, 1);
                            printfVals.push_back(evalExpr(arg, fields));
                        }
                        
                        std::string output;
                        size_t valIdx = 0;
                        for (size_t i = 0; i < fmt.length(); ++i) {
                            if (fmt[i] == '%' && i + 1 < fmt.length()) {
                                char spec = fmt[i + 1];
                                if (spec == 's' && valIdx < printfVals.size()) {
                                    output += printfVals[valIdx++];
                                    i++;
                                } else if (spec == 'd' && valIdx < printfVals.size()) {
                                    try { output += std::to_string(std::stoi(printfVals[valIdx++])); } catch (...) { output += "0"; }
                                    i++;
                                } else if (spec == '%') {
                                    output += '%';
                                    i++;
                                } else {
                                    output += fmt[i];
                                }
                            } else if (fmt[i] == '\\' && i + 1 < fmt.length()) {
                                char esc = fmt[i + 1];
                                if (esc == 'n') output += '\n';
                                else if (esc == 't') output += '\t';
                                else output += esc;
                                i++;
                            } else {
                                output += fmt[i];
                            }
                        }
                        std::cout << output;
                    }
                }
            }
        };

        std::string beginBlock, endBlock, mainBlock;
        size_t beginPos = program.find("BEGIN");
        size_t endPos = program.find("END");
        
        if (beginPos != std::string::npos) {
            size_t braceStart = program.find('{', beginPos);
            if (braceStart != std::string::npos) {
                int braceCount = 1;
                size_t braceEnd = braceStart + 1;
                while (braceEnd < program.length() && braceCount > 0) {
                    if (program[braceEnd] == '{') braceCount++;
                    else if (program[braceEnd] == '}') braceCount--;
                    braceEnd++;
                }
                beginBlock = program.substr(braceStart, braceEnd - braceStart);
            }
        }
        
        if (endPos != std::string::npos) {
            size_t braceStart = program.find('{', endPos);
            if (braceStart != std::string::npos) {
                int braceCount = 1;
                size_t braceEnd = braceStart + 1;
                while (braceEnd < program.length() && braceCount > 0) {
                    if (program[braceEnd] == '{') braceCount++;
                    else if (program[braceEnd] == '}') braceCount--;
                    braceEnd++;
                }
                endBlock = program.substr(braceStart, braceEnd - braceStart);
            }
        }
        
        size_t mainStart = program.find('{');
        if (mainStart != std::string::npos) {
            if (beginPos != std::string::npos && mainStart > beginPos && mainStart < beginPos + 10) {
                mainStart = program.find('}', mainStart);
                if (mainStart != std::string::npos) mainStart = program.find('{', mainStart);
            }
            if (mainStart != std::string::npos && endPos != std::string::npos && mainStart > endPos) {
                mainStart = std::string::npos;
            }
            if (mainStart != std::string::npos) {
                int braceCount = 1;
                size_t braceEnd = mainStart + 1;
                while (braceEnd < program.length() && braceCount > 0) {
                    if (program[braceEnd] == '{') braceCount++;
                    else if (program[braceEnd] == '}') braceCount--;
                    braceEnd++;
                }
                mainBlock = program.substr(mainStart, braceEnd - mainStart);
            }
        }
        
        if (mainBlock.empty() && beginBlock.empty() && endBlock.empty()) {
            mainBlock = program;
        }

        if (!beginBlock.empty()) {
            std::vector<std::string> emptyFields = {""};
            parseAction(beginBlock, emptyFields);
        }

        auto processLine = [&](const std::string& line, const std::string& filename) {
            int nr = std::stoi(vars["NR"]) + 1;
            vars["NR"] = std::to_string(nr);
            vars["FILENAME"] = filename;
            
            std::vector<std::string> fields = splitFields(line);
            
            if (!mainBlock.empty()) {
                parseAction(mainBlock, fields);
            }
        };

        if (!pipedInput.empty()) {
            std::istringstream iss(pipedInput);
            std::string line;
            while (std::getline(iss, line)) {
                processLine(line, "");
            }
        } else if (!files.empty()) {
            for (const auto& filePath : files) {
                std::ifstream file(resolvePath(filePath));
                if (!file) {
                    printError("awk: cannot open '" + filePath + "'");
                    continue;
                }
                std::string line;
                while (std::getline(file, line)) {
                    processLine(line, filePath);
                }
            }
        } else {
            std::string line;
            while (std::getline(std::cin, line)) {
                processLine(line, "");
            }
        }

        if (!endBlock.empty()) {
            std::vector<std::string> emptyFields = {""};
            parseAction(endBlock, emptyFields);
        }
    }

    // diff - compare files line by line
    void cmdDiff(const std::vector<std::string>& args) {
        if (args.size() < 3) {
            printError("diff: missing file operands");
            std::cout << "Usage: diff file1 file2\n";
            return;
        }
        
        bool unified = false;
        std::string file1Path, file2Path;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-u") unified = true;
            else if (file1Path.empty()) file1Path = args[i];
            else if (file2Path.empty()) file2Path = args[i];
        }
        
        std::ifstream f1(resolvePath(file1Path));
        std::ifstream f2(resolvePath(file2Path));
        
        if (!f1) {
            printError("diff: cannot open '" + file1Path + "'");
            return;
        }
        if (!f2) {
            printError("diff: cannot open '" + file2Path + "'");
            return;
        }
        
        std::vector<std::string> lines1, lines2;
        std::string line;
        while (std::getline(f1, line)) lines1.push_back(line);
        while (std::getline(f2, line)) lines2.push_back(line);
        
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        
        if (unified) {
            std::cout << "--- " << file1Path << "\n";
            std::cout << "+++ " << file2Path << "\n";
        }
        
        // Simple diff algorithm (line-by-line comparison)
        size_t i = 0, j = 0;
        while (i < lines1.size() || j < lines2.size()) {
            if (i >= lines1.size()) {
                // Remaining lines only in file2
                SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "+ " << lines2[j++] << "\n";
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            } else if (j >= lines2.size()) {
                // Remaining lines only in file1
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
                std::cout << "- " << lines1[i++] << "\n";
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            } else if (lines1[i] == lines2[j]) {
                // Lines match
                if (unified) {
                    std::cout << "  " << lines1[i] << "\n";
                }
                i++; j++;
            } else {
                // Lines differ - look ahead for resync
                bool foundMatch = false;
                for (size_t look = 1; look < 5 && !foundMatch; ++look) {
                    if (j + look < lines2.size() && lines1[i] == lines2[j + look]) {
                        // Extra lines in file2
                        for (size_t k = 0; k < look; ++k) {
                            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                            std::cout << "+ " << lines2[j++] << "\n";
                            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                        }
                        foundMatch = true;
                    } else if (i + look < lines1.size() && lines1[i + look] == lines2[j]) {
                        // Extra lines in file1
                        for (size_t k = 0; k < look; ++k) {
                            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
                            std::cout << "- " << lines1[i++] << "\n";
                            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                        }
                        foundMatch = true;
                    }
                }
                if (!foundMatch) {
                    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
                    std::cout << "- " << lines1[i++] << "\n";
                    SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    std::cout << "+ " << lines2[j++] << "\n";
                    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                }
            }
        }
    }

    // tee - read from stdin and write to stdout and files
    void cmdTee(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        if (pipedInput.empty()) {
            printError("tee: requires piped input");
            return;
        }
        
        bool appendMode = false;
        std::vector<std::string> files;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-a") appendMode = true;
            else if (args[i][0] != '-') files.push_back(resolvePath(args[i]));
        }
        
        // Write to stdout
        std::cout << pipedInput;
        
        // Write to files
        for (const auto& filePath : files) {
            std::ofstream file;
            if (appendMode) {
                file.open(filePath, std::ios::app);
            } else {
                file.open(filePath, std::ios::out);
            }
            if (file) {
                file << pipedInput;
            } else {
                printError("tee: cannot write to '" + filePath + "'");
            }
        }
    }

    // xargs - build and execute command lines from stdin
    void cmdXargs(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        if (pipedInput.empty()) {
            printError("xargs: requires piped input");
            return;
        }
        
        std::string command = "echo";  // Default command
        bool verbose = false;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-t") verbose = true;
            else if (args[i][0] != '-') {
                command = args[i];
                for (size_t j = i + 1; j < args.size(); ++j) {
                    command += " " + args[j];
                }
                break;
            }
        }
        
        // Collect arguments from input
        std::vector<std::string> inputArgs;
        std::istringstream iss(pipedInput);
        std::string arg;
        while (iss >> arg) {
            inputArgs.push_back(arg);
        }
        
        // Build command line
        std::string cmdLine = command;
        for (const auto& a : inputArgs) {
            cmdLine += " \"" + a + "\"";
        }
        
        if (verbose) {
            std::cout << cmdLine << "\n";
        }
        
        // Execute
        std::vector<std::string> tokens = tokenize(cmdLine);
        executeCommand(tokens);
    }

    // rev - reverse lines character-wise
    void cmdRev(const std::vector<std::string>& args, const std::string& pipedInput = "") {
        std::vector<std::string> lines;
        
        if (!pipedInput.empty()) {
            std::istringstream iss(pipedInput);
            std::string line;
            while (std::getline(iss, line)) {
                lines.push_back(line);
            }
        } else if (args.size() > 1) {
            std::ifstream file(resolvePath(args[1]));
            if (!file) {
                printError("rev: cannot open '" + args[1] + "'");
                return;
            }
            std::string line;
            while (std::getline(file, line)) {
                lines.push_back(line);
            }
        } else {
            printError("rev: missing file operand or piped input");
            return;
        }
        
        for (const auto& line : lines) {
            std::string reversed(line.rbegin(), line.rend());
            std::cout << reversed << "\n";
        }
    }

    // ============================================================================
    // FILE OPERATIONS COMMANDS
    // ============================================================================

    void cmdLn(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("ln: missing operand");
            return;
        }
        
        bool symbolic = false;
        bool force = false;
        bool noDereference = false;
        bool verbose = false;
        bool relative = false;
        std::vector<std::string> targets;
        std::string linkName;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i][0] == '-' && args[i].length() > 1) {
                for (size_t j = 1; j < args[i].length(); ++j) {
                    char flag = args[i][j];
                    if (flag == 's') symbolic = true;
                    else if (flag == 'f') force = true;
                    else if (flag == 'n') noDereference = true;
                    else if (flag == 'v') verbose = true;
                    else if (flag == 'r') relative = true;
                }
            } else {
                if (linkName.empty()) {
                    targets.push_back(args[i]);
                } else {
                    targets.push_back(linkName);
                    linkName = args[i];
                }
                if (targets.size() == 1 && i == args.size() - 1) {
                    linkName = targets[0];
                    targets.clear();
                } else if (i == args.size() - 1) {
                    linkName = args[i];
                    targets.pop_back();
                }
            }
        }
        
        if (targets.empty() && !linkName.empty()) {
            targets.push_back(linkName);
            linkName = fs::path(linkName).filename().string();
        }

        for (const auto& target : targets) {
            std::string targetPath = resolvePath(target);
            std::string actualLinkPath;
            
            if (fs::is_directory(resolvePath(linkName))) {
                actualLinkPath = resolvePath(linkName) + "\\" + fs::path(target).filename().string();
            } else {
                actualLinkPath = resolvePath(linkName);
            }
            
            if (force && fs::exists(actualLinkPath)) {
                try { fs::remove(actualLinkPath); } catch (...) {}
            }
            
            if (fs::exists(actualLinkPath) && !noDereference) {
                printError("ln: failed to create link '" + actualLinkPath + "': File exists");
                continue;
            }
            
            std::string linkTarget = targetPath;
            if (relative && symbolic) {
                fs::path linkDir = fs::path(actualLinkPath).parent_path();
                linkTarget = fs::relative(targetPath, linkDir).string();
            }
            
            if (!symbolic) {
                if (CreateHardLinkA(actualLinkPath.c_str(), targetPath.c_str(), NULL)) {
                    if (verbose) std::cout << "'" << actualLinkPath << "' => '" << target << "'\n";
                } else {
                    printError("ln: failed to create hard link (error " + std::to_string(GetLastError()) + ")");
                }
            } else {
                DWORD flags = 0;
                try { if (fs::is_directory(targetPath)) flags = SYMBOLIC_LINK_FLAG_DIRECTORY; } catch (...) {}
                flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
                
                if (CreateSymbolicLinkA(actualLinkPath.c_str(), linkTarget.c_str(), flags)) {
                    if (verbose) std::cout << "'" << actualLinkPath << "' -> '" << linkTarget << "'\n";
                } else {
                    DWORD error = GetLastError();
                    if (error == ERROR_PRIVILEGE_NOT_HELD) {
                        printError("ln: symbolic links require admin privileges or Developer Mode");
                    } else {
                        printError("ln: failed to create symbolic link (error " + std::to_string(error) + ")");
                    }
                }
            }
        }
    }

    void cmdStat(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("stat: missing file operand");
            return;
        }
        
        std::string format;
        bool followSymlinks = false;
        bool terse = false;
        std::vector<std::string> files;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if ((args[i] == "-c" || args[i] == "--format") && i + 1 < args.size()) {
                format = args[++i];
            } else if (args[i].substr(0, 10) == "--format=") {
                format = args[i].substr(10);
            } else if (args[i] == "-L" || args[i] == "--dereference") {
                followSymlinks = true;
            } else if (args[i] == "-t" || args[i] == "--terse") {
                terse = true;
            } else if (args[i][0] != '-') {
                files.push_back(args[i]);
            }
        }
        
        for (const auto& arg : files) {
            std::string filePath = resolvePath(arg);
            
            if (followSymlinks && fs::is_symlink(filePath)) {
                try { filePath = fs::canonical(filePath).string(); } catch (...) {}
            }
            
            if (!fs::exists(filePath)) {
                printError("stat: cannot stat '" + arg + "': No such file or directory");
                continue;
            }
            
            try {
                auto fileSize = fs::is_regular_file(filePath) ? fs::file_size(filePath) : 0;
                auto lastWrite = fs::last_write_time(filePath);
                auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                    lastWrite - fs::file_time_type::clock::now() + std::chrono::system_clock::now());
                auto modTime = std::chrono::system_clock::to_time_t(sctp);
                
                std::string fileType;
                if (fs::is_regular_file(filePath)) fileType = "regular file";
                else if (fs::is_directory(filePath)) fileType = "directory";
                else if (fs::is_symlink(filePath)) fileType = "symbolic link";
                else fileType = "unknown";
                
                DWORD attrs = GetFileAttributesA(filePath.c_str());
                std::string attrStr;
                if (attrs & FILE_ATTRIBUTE_READONLY) attrStr += "r";
                else attrStr += "-";
                attrStr += "w";
                if (filePath.find(".exe") != std::string::npos || filePath.find(".bat") != std::string::npos)
                    attrStr += "x";
                else attrStr += "-";
                
                BY_HANDLE_FILE_INFORMATION fileInfo;
                HANDLE hFile = CreateFileA(filePath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, 
                    OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
                DWORD nLinks = 1;
                DWORD fileIndex = 0;
                if (hFile != INVALID_HANDLE_VALUE) {
                    if (GetFileInformationByHandle(hFile, &fileInfo)) {
                        nLinks = fileInfo.nNumberOfLinks;
                        fileIndex = fileInfo.nFileIndexLow;
                    }
                    CloseHandle(hFile);
                }
                
                if (!format.empty()) {
                    std::string output = format;
                    size_t pos;
                    while ((pos = output.find("%n")) != std::string::npos)
                        output.replace(pos, 2, arg);
                    while ((pos = output.find("%N")) != std::string::npos)
                        output.replace(pos, 2, "'" + arg + "'");
                    while ((pos = output.find("%s")) != std::string::npos)
                        output.replace(pos, 2, std::to_string(fileSize));
                    while ((pos = output.find("%F")) != std::string::npos)
                        output.replace(pos, 2, fileType);
                    while ((pos = output.find("%A")) != std::string::npos)
                        output.replace(pos, 2, attrStr);
                    while ((pos = output.find("%h")) != std::string::npos)
                        output.replace(pos, 2, std::to_string(nLinks));
                    while ((pos = output.find("%i")) != std::string::npos)
                        output.replace(pos, 2, std::to_string(fileIndex));
                    while ((pos = output.find("%Y")) != std::string::npos)
                        output.replace(pos, 2, std::to_string(modTime));
                    while ((pos = output.find("%y")) != std::string::npos) {
                        char timeBuf[64];
                        strftime(timeBuf, sizeof(timeBuf), "%Y-%m-%d %H:%M:%S", localtime(&modTime));
                        output.replace(pos, 2, timeBuf);
                    }
                    while ((pos = output.find("\\n")) != std::string::npos)
                        output.replace(pos, 2, "\n");
                    std::cout << output << "\n";
                } else if (terse) {
                    std::cout << arg << " " << fileSize << " " << nLinks << " " << modTime << "\n";
                } else {
                    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
                    SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    std::cout << "  File: ";
                    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                    std::cout << arg << "\n";
                    std::cout << "  Size: " << fileSize << "       \tBlocks: " << (fileSize / 512 + 1) 
                              << "     \tLinks: " << nLinks << "\n";
                    std::cout << "  Type: " << fileType << "\n";
                    std::cout << " Attrs: ";
                    if (attrs & FILE_ATTRIBUTE_READONLY) std::cout << "readonly ";
                    if (attrs & FILE_ATTRIBUTE_HIDDEN) std::cout << "hidden ";
                    if (attrs & FILE_ATTRIBUTE_SYSTEM) std::cout << "system ";
                    if (attrs & FILE_ATTRIBUTE_ARCHIVE) std::cout << "archive ";
                    if (attrs & FILE_ATTRIBUTE_DIRECTORY) std::cout << "directory ";
                    std::cout << "\n";
                    std::cout << "Modify: " << std::ctime(&modTime);
                    std::cout << "\n";
                }
            } catch (const std::exception& e) {
                printError("stat: " + std::string(e.what()));
            }
        }
    }

    void cmdFile(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("file: missing file operand");
            return;
        }
        
        bool brief = false;
        bool mimeType = false;
        std::vector<std::string> files;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-b" || args[i] == "--brief") brief = true;
            else if (args[i] == "-i" || args[i] == "--mime-type") mimeType = true;
            else if (args[i][0] != '-') files.push_back(args[i]);
        }
        
        for (const auto& arg : files) {
            std::string filePath = resolvePath(arg);
            
            if (!fs::exists(filePath)) {
                if (!brief) std::cout << arg << ": ";
                std::cout << "cannot open (No such file or directory)\n";
                continue;
            }
            
            if (!brief) std::cout << arg << ": ";
            
            if (fs::is_directory(filePath)) {
                std::cout << (mimeType ? "inode/directory" : "directory") << "\n";
                continue;
            }
            
            if (fs::is_symlink(filePath)) {
                std::cout << (mimeType ? "inode/symlink" : "symbolic link") << "\n";
                continue;
            }
            
            std::ifstream file(filePath, std::ios::binary);
            if (!file) {
                std::cout << "cannot open\n";
                continue;
            }
            
            unsigned char magic[32] = {0};
            file.read(reinterpret_cast<char*>(magic), 32);
            size_t bytesRead = file.gcount();
            
            if (bytesRead == 0) {
                std::cout << (mimeType ? "inode/x-empty" : "empty") << "\n";
                continue;
            }
            
            if (magic[0] == 0x4D && magic[1] == 0x5A) {
                std::cout << (mimeType ? "application/x-dosexec" : "PE32 executable (Windows)") << "\n";
            } else if (magic[0] == 0x7F && magic[1] == 'E' && magic[2] == 'L' && magic[3] == 'F') {
                std::cout << (mimeType ? "application/x-executable" : "ELF executable") << "\n";
            } else if (magic[0] == 0xCA && magic[1] == 0xFE && magic[2] == 0xBA && magic[3] == 0xBE) {
                std::cout << (mimeType ? "application/x-mach-binary" : "Mach-O universal binary") << "\n";
            } else if (magic[0] == 0x89 && magic[1] == 'P' && magic[2] == 'N' && magic[3] == 'G') {
                std::cout << (mimeType ? "image/png" : "PNG image data") << "\n";
            } else if (magic[0] == 0xFF && magic[1] == 0xD8 && magic[2] == 0xFF) {
                std::cout << (mimeType ? "image/jpeg" : "JPEG image data") << "\n";
            } else if (magic[0] == 'G' && magic[1] == 'I' && magic[2] == 'F' && magic[3] == '8') {
                std::cout << (mimeType ? "image/gif" : "GIF image data") << "\n";
            } else if (magic[0] == 'B' && magic[1] == 'M') {
                std::cout << (mimeType ? "image/bmp" : "BMP image data") << "\n";
            } else if (magic[0] == 0x00 && magic[1] == 0x00 && magic[2] == 0x01 && magic[3] == 0x00) {
                std::cout << (mimeType ? "image/x-icon" : "ICO image data") << "\n";
            } else if (magic[0] == 'R' && magic[1] == 'I' && magic[2] == 'F' && magic[3] == 'F') {
                if (magic[8] == 'W' && magic[9] == 'A' && magic[10] == 'V' && magic[11] == 'E') {
                    std::cout << (mimeType ? "audio/wav" : "WAV audio") << "\n";
                } else if (magic[8] == 'A' && magic[9] == 'V' && magic[10] == 'I') {
                    std::cout << (mimeType ? "video/avi" : "AVI video") << "\n";
                } else if (magic[8] == 'W' && magic[9] == 'E' && magic[10] == 'B' && magic[11] == 'P') {
                    std::cout << (mimeType ? "image/webp" : "WebP image") << "\n";
                } else {
                    std::cout << (mimeType ? "application/octet-stream" : "RIFF data") << "\n";
                }
            } else if (magic[0] == 'O' && magic[1] == 'g' && magic[2] == 'g' && magic[3] == 'S') {
                std::cout << (mimeType ? "application/ogg" : "Ogg data") << "\n";
            } else if (magic[0] == 'f' && magic[1] == 'L' && magic[2] == 'a' && magic[3] == 'C') {
                std::cout << (mimeType ? "audio/flac" : "FLAC audio") << "\n";
            } else if (magic[0] == 0xFF && (magic[1] & 0xE0) == 0xE0) {
                std::cout << (mimeType ? "audio/mpeg" : "MP3 audio") << "\n";
            } else if (magic[0] == 'I' && magic[1] == 'D' && magic[2] == '3') {
                std::cout << (mimeType ? "audio/mpeg" : "MP3 audio (ID3 tag)") << "\n";
            } else if (magic[4] == 'f' && magic[5] == 't' && magic[6] == 'y' && magic[7] == 'p') {
                std::cout << (mimeType ? "video/mp4" : "MP4/M4A media") << "\n";
            } else if (magic[0] == 0x1A && magic[1] == 0x45 && magic[2] == 0xDF && magic[3] == 0xA3) {
                std::cout << (mimeType ? "video/webm" : "WebM/MKV video") << "\n";
            } else if (magic[0] == 'P' && magic[1] == 'K' && magic[2] == 0x03 && magic[3] == 0x04) {
                file.seekg(30);
                char nameTest[8] = {0};
                file.read(nameTest, 8);
                if (strncmp(nameTest, "word/", 5) == 0) {
                    std::cout << (mimeType ? "application/vnd.openxmlformats-officedocument.wordprocessingml.document" : "Microsoft Word 2007+ document") << "\n";
                } else if (strncmp(nameTest, "xl/", 3) == 0) {
                    std::cout << (mimeType ? "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" : "Microsoft Excel 2007+ spreadsheet") << "\n";
                } else if (strncmp(nameTest, "ppt/", 4) == 0) {
                    std::cout << (mimeType ? "application/vnd.openxmlformats-officedocument.presentationml.presentation" : "Microsoft PowerPoint 2007+ presentation") << "\n";
                } else {
                    std::cout << (mimeType ? "application/zip" : "Zip archive data") << "\n";
                }
            } else if (magic[0] == 0x1F && magic[1] == 0x8B) {
                std::cout << (mimeType ? "application/gzip" : "gzip compressed data") << "\n";
            } else if (magic[0] == 0x42 && magic[1] == 0x5A && magic[2] == 0x68) {
                std::cout << (mimeType ? "application/x-bzip2" : "bzip2 compressed data") << "\n";
            } else if (magic[0] == 0xFD && magic[1] == 0x37 && magic[2] == 0x7A && magic[3] == 0x58 && magic[4] == 0x5A) {
                std::cout << (mimeType ? "application/x-xz" : "XZ compressed data") << "\n";
            } else if (magic[0] == 0x37 && magic[1] == 0x7A && magic[2] == 0xBC && magic[3] == 0xAF) {
                std::cout << (mimeType ? "application/x-7z-compressed" : "7-zip archive data") << "\n";
            } else if (magic[0] == 0x52 && magic[1] == 0x61 && magic[2] == 0x72 && magic[3] == 0x21) {
                std::cout << (mimeType ? "application/x-rar" : "RAR archive data") << "\n";
            } else if (magic[0] == '%' && magic[1] == 'P' && magic[2] == 'D' && magic[3] == 'F') {
                std::cout << (mimeType ? "application/pdf" : "PDF document") << "\n";
            } else if (magic[0] == 0xD0 && magic[1] == 0xCF && magic[2] == 0x11 && magic[3] == 0xE0) {
                std::cout << (mimeType ? "application/msword" : "Microsoft Office document (OLE)") << "\n";
            } else if (magic[0] == 0x25 && magic[1] == 0x21 && magic[2] == 0x50 && magic[3] == 0x53) {
                std::cout << (mimeType ? "application/postscript" : "PostScript document") << "\n";
            } else if (magic[0] == 0xEF && magic[1] == 0xBB && magic[2] == 0xBF) {
                std::cout << (mimeType ? "text/plain; charset=utf-8" : "UTF-8 Unicode text (with BOM)") << "\n";
            } else if (magic[0] == 0xFE && magic[1] == 0xFF) {
                std::cout << (mimeType ? "text/plain; charset=utf-16be" : "UTF-16 BE Unicode text") << "\n";
            } else if (magic[0] == 0xFF && magic[1] == 0xFE) {
                std::cout << (mimeType ? "text/plain; charset=utf-16le" : "UTF-16 LE Unicode text") << "\n";
            } else if (magic[0] == '<' && magic[1] == '?') {
                if (magic[2] == 'x' && magic[3] == 'm' && magic[4] == 'l') {
                    std::cout << (mimeType ? "application/xml" : "XML document") << "\n";
                } else {
                    std::cout << (mimeType ? "text/x-php" : "PHP script") << "\n";
                }
            } else if (magic[0] == '<' && magic[1] == '!' && magic[2] == 'D') {
                std::cout << (mimeType ? "text/html" : "HTML document") << "\n";
            } else if (magic[0] == '<' && (magic[1] == 'h' || magic[1] == 'H')) {
                std::cout << (mimeType ? "text/html" : "HTML document") << "\n";
            } else if (magic[0] == '{' || magic[0] == '[') {
                std::cout << (mimeType ? "application/json" : "JSON data") << "\n";
            } else if (magic[0] == '#' && magic[1] == '!') {
                std::cout << (mimeType ? "text/x-shellscript" : "script, shebang executable") << "\n";
            } else if (magic[0] == 0x00 && magic[1] == 0x00 && magic[2] == 0x00) {
                std::cout << (mimeType ? "application/octet-stream" : "binary data") << "\n";
            } else {
                bool isText = true;
                for (size_t j = 0; j < bytesRead; ++j) {
                    if (magic[j] < 0x09 || (magic[j] > 0x0D && magic[j] < 0x20 && magic[j] != 0x1B)) {
                        if (magic[j] != 0) isText = false;
                    }
                }
                if (isText) {
                    std::cout << (mimeType ? "text/plain" : "ASCII text") << "\n";
                } else {
                    std::cout << (mimeType ? "application/octet-stream" : "data") << "\n";
                }
            }
        }
    }

    // readlink - print resolved symbolic link
    void cmdReadlink(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("readlink: missing file operand");
            return;
        }
        
        bool canonicalize = false;
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-f" || args[i] == "-e" || args[i] == "-m") {
                canonicalize = true;
                continue;
            }
            if (args[i][0] == '-') continue;
            
            std::string filePath = resolvePath(args[i]);
            
            if (canonicalize) {
                try {
                    std::cout << fs::canonical(filePath).string() << "\n";
                } catch (...) {
                    std::cout << fs::absolute(filePath).string() << "\n";
                }
            } else {
                if (fs::is_symlink(filePath)) {
                    try {
                        std::cout << fs::read_symlink(filePath).string() << "\n";
                    } catch (const std::exception& e) {
                        printError("readlink: " + std::string(e.what()));
                    }
                } else {
                    printError("readlink: '" + args[i] + "' is not a symbolic link");
                }
            }
        }
    }

    // realpath - print resolved absolute path
    void cmdRealpath(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("realpath: missing file operand");
            return;
        }
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i][0] == '-') continue;
            
            std::string filePath = resolvePath(args[i]);
            
            try {
                if (fs::exists(filePath)) {
                    std::cout << fs::canonical(filePath).string() << "\n";
                } else {
                    std::cout << fs::absolute(filePath).string() << "\n";
                }
            } catch (const std::exception& e) {
                std::cout << fs::absolute(filePath).string() << "\n";
            }
        }
    }

    // basename - strip directory from filename
    void cmdBasename(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("basename: missing operand");
            return;
        }
        
        std::string suffix;
        if (args.size() > 2 && args[args.size() - 2] == "-s") {
            suffix = args[args.size() - 1];
        }
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-a" || args[i] == "-s") continue;
            if (i > 1 && args[i - 1] == "-s") continue;
            
            fs::path p(args[i]);
            std::string name = p.filename().string();
            
            if (!suffix.empty() && name.length() > suffix.length()) {
                if (name.substr(name.length() - suffix.length()) == suffix) {
                    name = name.substr(0, name.length() - suffix.length());
                }
            }
            
            std::cout << name << "\n";
        }
    }

    // dirname - strip filename from path
    void cmdDirname(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            printError("dirname: missing operand");
            return;
        }
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i][0] == '-') continue;
            
            fs::path p(args[i]);
            std::string dir = p.parent_path().string();
            if (dir.empty()) dir = ".";
            
            std::cout << dir << "\n";
        }
    }

    void cmdTree(const std::vector<std::string>& args) {
        std::string path = ".";
        int maxDepth = -1;
        bool dirsOnly = false;
        bool showHidden = false;
        bool showSize = false;
        bool humanReadable = false;
        bool showPermissions = false;
        bool fullPath = false;
        bool noReport = false;
        bool showDu = false;
        std::string ignorePattern;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-L" && i + 1 < args.size()) {
                try { maxDepth = std::stoi(args[++i]); } catch (...) {}
            } else if (args[i] == "-d") {
                dirsOnly = true;
            } else if (args[i] == "-a") {
                showHidden = true;
            } else if (args[i] == "-s") {
                showSize = true;
            } else if (args[i] == "-h") {
                humanReadable = true;
            } else if (args[i] == "-p") {
                showPermissions = true;
            } else if (args[i] == "-f") {
                fullPath = true;
            } else if (args[i] == "--noreport") {
                noReport = true;
            } else if (args[i] == "--du") {
                showDu = true;
                showSize = true;
            } else if ((args[i] == "-I" || args[i] == "--ignore") && i + 1 < args.size()) {
                ignorePattern = args[++i];
            } else if (args[i][0] != '-') {
                path = args[i];
            }
        }
        
        std::string rootPath = resolvePath(path);
        if (!fs::exists(rootPath) || !fs::is_directory(rootPath)) {
            printError("tree: '" + path + "' is not a directory");
            return;
        }
        
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << (fullPath ? rootPath : path) << "\n";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        
        int dirCount = 0, fileCount = 0;
        uintmax_t totalSize = 0;

        auto formatSize = [](uintmax_t bytes, bool human) -> std::string {
            if (!human) return std::to_string(bytes);
            const char* units[] = {"B", "K", "M", "G", "T"};
            int u = 0;
            double size = (double)bytes;
            while (size >= 1024 && u < 4) { size /= 1024; u++; }
            char buf[32];
            if (u == 0) snprintf(buf, sizeof(buf), "%4d%s", (int)size, units[u]);
            else snprintf(buf, sizeof(buf), "%4.1f%s", size, units[u]);
            return buf;
        };

        std::function<uintmax_t(const fs::path&, const std::string&, int)> printTree;
        printTree = [&](const fs::path& p, const std::string& prefix, int depth) -> uintmax_t {
            if (maxDepth >= 0 && depth >= maxDepth) return 0;
            
            std::vector<fs::directory_entry> entries;
            try {
                for (const auto& entry : fs::directory_iterator(p)) {
                    std::string name = entry.path().filename().string();
                    if (!showHidden && name[0] == '.') continue;
                    if (!ignorePattern.empty()) {
                        try {
                            std::regex re(ignorePattern);
                            if (std::regex_search(name, re)) continue;
                        } catch (...) {
                            if (name.find(ignorePattern) != std::string::npos) continue;
                        }
                    }
                    if (dirsOnly && !entry.is_directory()) continue;
                    entries.push_back(entry);
                }
            } catch (...) {
                return 0;
            }
            
            std::sort(entries.begin(), entries.end(), [](const auto& a, const auto& b) {
                return a.path().filename() < b.path().filename();
            });
            
            uintmax_t dirSize = 0;
            
            for (size_t i = 0; i < entries.size(); ++i) {
                const auto& entry = entries[i];
                bool isLast = (i == entries.size() - 1);
                
                std::cout << prefix << (isLast ? "`-- " : "|-- ");
                
                uintmax_t entrySize = 0;
                if (entry.is_directory()) {
                    if (showDu) {
                        entrySize = printTree(entry.path(), prefix + (isLast ? "    " : "|   "), depth + 1);
                    }
                } else {
                    try { entrySize = fs::file_size(entry.path()); } catch (...) {}
                }
                
                if (showPermissions) {
                    DWORD attrs = GetFileAttributesA(entry.path().string().c_str());
                    std::cout << "[" << (attrs & FILE_ATTRIBUTE_DIRECTORY ? "d" : "-")
                              << (attrs & FILE_ATTRIBUTE_READONLY ? "r-" : "rw")
                              << (attrs & FILE_ATTRIBUTE_HIDDEN ? "h" : "-") << "] ";
                }
                
                if (showSize) {
                    std::cout << "[" << std::setw(8) << formatSize(entrySize, humanReadable) << "]  ";
                }
                
                if (entry.is_directory()) {
                    SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    std::cout << (fullPath ? entry.path().string() : entry.path().filename().string()) << "\n";
                    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                    dirCount++;
                    if (!showDu) {
                        printTree(entry.path(), prefix + (isLast ? "    " : "|   "), depth + 1);
                    }
                    dirSize += entrySize;
                } else {
                    std::cout << (fullPath ? entry.path().string() : entry.path().filename().string()) << "\n";
                    fileCount++;
                    dirSize += entrySize;
                    totalSize += entrySize;
                }
            }
            return dirSize;
        };
        
        printTree(rootPath, "", 0);
        
        if (!noReport) {
            std::cout << "\n" << dirCount << " directories";
            if (!dirsOnly) {
                std::cout << ", " << fileCount << " files";
                if (showSize) {
                    std::cout << " (" << formatSize(totalSize, humanReadable) << " total)";
                }
            }
            std::cout << "\n";
        }
    }

    void cmdDu(const std::vector<std::string>& args) {
        bool humanReadable = false;
        bool summary = false;
        bool showAll = false;
        bool showTotal = false;
        bool showTime = false;
        bool apparentSize = false;
        int maxDepth = -1;
        int blockSize = 1024;
        std::string excludePattern;
        std::vector<std::string> paths;
        
        for (size_t i = 1; i < args.size(); ++i) {
            if (args[i] == "-h" || args[i] == "--human-readable") humanReadable = true;
            else if (args[i] == "-s" || args[i] == "--summarize") summary = true;
            else if (args[i] == "-a" || args[i] == "--all") showAll = true;
            else if (args[i] == "-c" || args[i] == "--total") showTotal = true;
            else if (args[i] == "-b" || args[i] == "--bytes") { blockSize = 1; apparentSize = true; }
            else if (args[i] == "-k") blockSize = 1024;
            else if (args[i] == "-m") blockSize = 1024 * 1024;
            else if (args[i] == "--time") showTime = true;
            else if (args[i] == "--apparent-size") apparentSize = true;
            else if ((args[i] == "-d" || args[i] == "--max-depth") && i + 1 < args.size()) {
                try { maxDepth = std::stoi(args[++i]); } catch (...) {}
            } else if (args[i].substr(0, 2) == "-d") {
                try { maxDepth = std::stoi(args[i].substr(2)); } catch (...) {}
            } else if ((args[i] == "--exclude") && i + 1 < args.size()) {
                excludePattern = args[++i];
            } else if (args[i][0] != '-') {
                paths.push_back(args[i]);
            }
        }
        
        if (paths.empty()) paths.push_back(".");
        
        auto formatSize = [humanReadable, blockSize](uintmax_t bytes) -> std::string {
            if (humanReadable) {
                const char* units[] = {"B", "K", "M", "G", "T"};
                int unit = 0;
                double size = (double)bytes;
                while (size >= 1024 && unit < 4) { size /= 1024; unit++; }
                std::ostringstream oss;
                if (unit == 0) oss << (int)size << units[unit];
                else oss << std::fixed << std::setprecision(1) << size << units[unit];
                return oss.str();
            }
            return std::to_string(bytes / blockSize);
        };
        
        uintmax_t grandTotal = 0;
        
        for (const auto& path : paths) {
            std::string fullPath = resolvePath(path);
            
            if (!fs::exists(fullPath)) {
                printError("du: cannot access '" + path + "': No such file or directory");
                continue;
            }
            
            std::function<uintmax_t(const fs::path&, int)> calcSize;
            calcSize = [&](const fs::path& p, int depth) -> uintmax_t {
                uintmax_t total = 0;
                
                try {
                    if (fs::is_regular_file(p)) {
                        uintmax_t fsize = fs::file_size(p);
                        if (showAll && !summary) {
                            std::cout << std::setw(8) << formatSize(fsize) << "\t" << p.string() << "\n";
                        }
                        return fsize;
                    }
                    
                    for (const auto& entry : fs::directory_iterator(p, fs::directory_options::skip_permission_denied)) {
                        std::string name = entry.path().filename().string();
                        if (!excludePattern.empty()) {
                            try {
                                std::regex re(excludePattern);
                                if (std::regex_search(name, re)) continue;
                            } catch (...) {
                                if (name.find(excludePattern) != std::string::npos) continue;
                            }
                        }
                        
                        if (entry.is_directory()) {
                            uintmax_t dirSize = calcSize(entry.path(), depth + 1);
                            total += dirSize;
                            
                            if (!summary && (maxDepth < 0 || depth < maxDepth)) {
                                std::cout << std::setw(8) << formatSize(dirSize) << "\t";
                                if (showTime) {
                                    auto lwt = fs::last_write_time(entry.path());
                                    auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                                        lwt - fs::file_time_type::clock::now() + std::chrono::system_clock::now());
                                    auto time = std::chrono::system_clock::to_time_t(sctp);
                                    char timeBuf[64];
                                    strftime(timeBuf, sizeof(timeBuf), "%Y-%m-%d %H:%M", localtime(&time));
                                    std::cout << timeBuf << " ";
                                }
                                std::cout << entry.path().string() << "\n";
                            }
                        } else if (entry.is_regular_file()) {
                            uintmax_t fsize = fs::file_size(entry.path());
                            total += fsize;
                            if (showAll && !summary && (maxDepth < 0 || depth < maxDepth)) {
                                std::cout << std::setw(8) << formatSize(fsize) << "\t";
                                if (showTime) {
                                    auto lwt = fs::last_write_time(entry.path());
                                    auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                                        lwt - fs::file_time_type::clock::now() + std::chrono::system_clock::now());
                                    auto time = std::chrono::system_clock::to_time_t(sctp);
                                    char timeBuf[64];
                                    strftime(timeBuf, sizeof(timeBuf), "%Y-%m-%d %H:%M", localtime(&time));
                                    std::cout << timeBuf << " ";
                                }
                                std::cout << entry.path().string() << "\n";
                            }
                        }
                    }
                } catch (...) {}
                
                return total;
            };
            
            uintmax_t totalSize = calcSize(fullPath, 0);
            std::cout << std::setw(8) << formatSize(totalSize) << "\t" << path << "\n";
            grandTotal += totalSize;
        }
        
        if (showTotal && paths.size() > 1) {
            std::cout << std::setw(8) << formatSize(grandTotal) << "\ttotal\n";
        }
    }

    std::string getPackagesFilePath() {
        return (fs::path(getLinuxdbPath()) / "packages.lin").string();
    }

    std::map<std::string, std::string> loadPackageAliases() {
        std::map<std::string, std::string> aliases;
        std::ifstream file(getPackagesFilePath());
        
        if (!file) {
            return aliases;
        }
        
        std::string line;
        while (std::getline(file, line)) {
            if (line.empty() || line[0] == '#') continue;
            
            size_t pos = line.find('=');
            if (pos != std::string::npos) {
                std::string key = line.substr(0, pos);
                std::string value = line.substr(pos + 1);
                
                key.erase(0, key.find_first_not_of(" \t"));
                key.erase(key.find_last_not_of(" \t") + 1);
                value.erase(0, value.find_first_not_of(" \t"));
                value.erase(value.find_last_not_of(" \t") + 1);
                
                if (!key.empty() && !value.empty()) {
                    aliases[key] = value;
                }
            }
        }
        
        return aliases;
    }

    std::string resolvePackageName(const std::string& name) {
        auto aliases = loadPackageAliases();
        auto it = aliases.find(name);
        if (it != aliases.end()) {
            return it->second;
        }
        return name;
    }

    void cmdLin(const std::vector<std::string>& args) {
        if (args.size() < 2) {
            HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Lin Package Manager";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            std::cout << " - Linux-style wrapper for winget\n\n";
            
            std::cout << "Usage:\n";
            std::cout << "  lin get <package>      Install a package\n";
            std::cout << "  lin remove <package>   Uninstall a package\n";
            std::cout << "  lin search <query>     Search packages (auto-syncs)\n";
            std::cout << "  lin update             Check for updates\n";
            std::cout << "  lin upgrade            Upgrade all packages\n";
            std::cout << "  lin list               List installed packages\n";
            std::cout << "  lin info <package>     Show package info\n";
            std::cout << "  lin alias              Show all package aliases\n";
            std::cout << "  lin add <name> <id>    Add custom alias\n";
            return;
        }
        
        std::string subcmd = args[1];
        
        if (subcmd == "get" || subcmd == "install") {
            if (args.size() < 3) {
                printError("Usage: lin get <package>");
                return;
            }
            
            std::string package = resolvePackageName(args[2]);
            
            HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Installing: ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            std::cout << package << "\n\n";
            
            std::string cmd = "winget install --accept-package-agreements --accept-source-agreements " + package;
            runProcess(cmd);
            
        } else if (subcmd == "remove" || subcmd == "uninstall") {
            if (args.size() < 3) {
                printError("Usage: lin remove <package>");
                return;
            }
            
            std::string package = resolvePackageName(args[2]);
            
            HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
            std::cout << "Removing: ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            std::cout << package << "\n\n";
            
            std::string cmd = "winget uninstall " + package;
            runProcess(cmd);
            
        } else if (subcmd == "search" || subcmd == "find") {
            if (args.size() < 3) {
                printError("Usage: lin search <query>");
                return;
            }
            
            std::string query = args[2];
            std::string tempFile = getPackagesFilePath() + ".tmp";
            
            std::string cmd = "winget search " + query + " --accept-source-agreements";
            runProcess(cmd);
            
            std::cout << "\n";
            HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Syncing found packages to aliases...";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            
            // Run winget directly without cmd /c
            executeToFile("winget search " + query + " --accept-source-agreements", tempFile, "", false);
            
            
            auto existingAliases = loadPackageAliases();
            int addedCount = 0;
            
            std::ifstream ifs(tempFile);
            if (ifs) {
                std::string line;
                int lineNum = 0;
                
                while (std::getline(ifs, line)) {
                    lineNum++;
                    if (lineNum <= 2) continue;
                    if (line.empty() || line[0] == '-') continue;
                    if (line.find("Name") != std::string::npos && line.find("Id") != std::string::npos) continue;
                    
                    std::string name;
                    std::string packageId;
                    
                    size_t pos = 0;
                    while (pos < line.length() && line[pos] != ' ') {
                        name += line[pos];
                        pos++;
                    }
                    
                    while (pos < line.length() && line[pos] == ' ') pos++;
                    
                    while (pos < line.length() && line[pos] != ' ') {
                        packageId += line[pos];
                        pos++;
                    }
                    
                    if (packageId.length() > 3 && packageId.find('.') != std::string::npos) {
                        std::string alias = name;
                        std::transform(alias.begin(), alias.end(), alias.begin(), ::tolower);
                        alias.erase(std::remove_if(alias.begin(), alias.end(), 
                            [](char c) { return !isalnum(c) && c != '-' && c != '_'; }), alias.end());
                        
                        if (alias.length() >= 2 && alias.length() <= 30) {
                            if (existingAliases.find(alias) == existingAliases.end()) {
                                std::ofstream outFile(getPackagesFilePath(), std::ios::app);
                                if (outFile) {
                                    outFile << alias << "=" << packageId << "\n";
                                    outFile.close();
                                    existingAliases[alias] = packageId;
                                    addedCount++;
                                }
                            }
                        }
                    }
                }
                ifs.close();
            }
            
            fs::remove(tempFile);
            
            if (addedCount > 0) {
                std::cout << " added " << addedCount << " new aliases!\n";
            } else {
                std::cout << " (all packages already known)\n";
            }
            
        } else if (subcmd == "update") {
            std::cout << "Checking for updates...\n\n";
            runProcess("winget upgrade");
            
        } else if (subcmd == "upgrade") {
            std::cout << "Upgrading all packages...\n\n";
            runProcess("winget upgrade --all --accept-package-agreements --accept-source-agreements");
            
        } else if (subcmd == "list") {
            runProcess("winget list");
            
        } else if (subcmd == "info" || subcmd == "show") {
            if (args.size() < 3) {
                printError("Usage: lin info <package>");
                return;
            }
            
            std::string package = resolvePackageName(args[2]);
            std::string cmd = "winget show " + package;
            runProcess(cmd);
            
        } else if (subcmd == "alias" || subcmd == "aliases") {
            auto aliases = loadPackageAliases();
            
            HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Package Aliases";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            std::cout << " (" << aliases.size() << " total)\n\n";
            
            for (const auto& pair : aliases) {
                SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                std::cout << std::setw(15) << std::left << pair.first;
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                std::cout << " -> " << pair.second << "\n";
            }
            
        } else if (subcmd == "add" || subcmd == "add-alias") {
            if (args.size() < 4) {
                printError("Usage: lin add <alias-name> <winget-id>");
                return;
            }
            
            std::string aliasName = args[2];
            std::string wingetId = args[3];
            
            std::ofstream file(getPackagesFilePath(), std::ios::app);
            if (!file) {
                printError("Cannot write to packages.lin");
                return;
            }
            
            file << "\n" << aliasName << "=" << wingetId;
            file.close();
            
            printSuccess("Added alias: " + aliasName + " -> " + wingetId);
            
        } else {
            printError("Unknown lin command: " + subcmd);
            std::cout << "Type 'lin' for usage\n";
        }
    }

    void cmdHelp(const std::vector<std::string>& args) {
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
        std::cout << "\n  Linuxify Shell - Linux Commands for Windows\n";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "  ============================================\n\n";

        std::cout << "  File System Commands:\n\n";
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  pwd";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Print working directory\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cd <dir>";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Change directory\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  ls [-la]";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      List directory contents\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  mkdir [-p]";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "    Create directories\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  rm [-rf]";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Remove files or directories\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  mv";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            Move or rename files\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cp [-r]";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "       Copy files or directories\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cat [-n]";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Display file contents\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  touch";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Create files or update timestamps\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  chmod";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Change file permissions (+w/-w/+r/-r)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  chown";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Change file ownership (uses icacls)\n";

        std::cout << "\n  Utilities:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  calc";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Command-line calculator\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cal";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Calendar\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cmatrix";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "       Matrix digital rain\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cowsay";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "        ASCII cow speech\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  printf";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "        Format and print data\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  clear";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Clear the screen\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  echo";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Print text (supports $VAR expansion)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  history";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "       Show command history (-c to clear)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  whoami";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "        Show current username\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  env/printenv";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "  Show environment variables\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  export";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "        Set env var ([-p] persist, [-arr] array)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  var";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Manage persistent variables (list, mod, insert, purge, del)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  alias";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Create command aliases\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  unalias";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "       Remove aliases\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  which";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Find command location\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  type";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Describe a command\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  help";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Show this help message\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lino";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Text editor\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  sudo <cmd>";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "    Run as Administrator (Windows 11)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  sleep <sec>";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "   Delay execution\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  yes [str]";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "     Output string repeatedly\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  date";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Print system date/time\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  seq";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Print a sequence of numbers\n";

        std::cout << "\n  Package Management:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lin";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Package manager (lin get, lin remove, ...)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  registry";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      External command registry (refresh, list)\n";

        std::cout << "\n  External Commands:\n\n";
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "  Installed tools like git, node, python, mysql, etc.\n";
        std::cout << "  Run 'registry refresh' to scan for installed commands.\n";

        std::cout << "\n  Process Management:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  ps";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            List ctx.running processes (-aux for details)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  kill";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Terminate process (kill <PID> or kill %<job>)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  top";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Live process monitor (press 'q' to quit)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  jobs";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          List background jobs\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  fg";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            Bring job to foreground (fg %<job>)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  <cmd> &";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "       Run command in background\n";

        std::cout << "\n  Text Processing:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  grep";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Search for pattern (-i -n -v)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  head";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Show first N lines (head -n 10)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  tail";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Show last N lines (tail -n 10)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  wc";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            Count lines/words/chars (-l -w -c)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  sort";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Sort lines (-r reverse, -n numeric)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  uniq";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Remove duplicate lines (-c count)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  find";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Find files (find . -name \"*.txt\")\n";

        std::cout << "\n  Text Processing (Extended):\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  less/more";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "     Pager for viewing files (q to quit)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cut";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Extract columns (-d delim -f fields)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  tr";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            Translate characters (tr a-z A-Z)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  sed";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Stream editor (sed 's/old/new/g')\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  awk";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Field extraction (awk '{print $1}')\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  diff";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Compare files (diff file1 file2)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  tee";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Write to stdout and file (-a append)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  xargs";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Build command from stdin\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  rev";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Reverse lines character-wise\n";

        std::cout << "\n  File Operations:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  mount";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Mount custom filesystems\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  umount";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "        Unmount filesystems\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  ln";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            Create links (-s for symbolic)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  stat";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Display file status/metadata\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  file";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Determine file type\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  readlink";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Print resolved symlink target\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  realpath";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Resolve to absolute path\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  basename";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Strip directory from path\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  dirname";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "       Strip filename from path\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  tree";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Directory tree view (-L depth)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  du";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            Disk usage (-h human, -s summary)\n";

        std::cout << "\n  Redirection & Piping:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cmd > file";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "    Write stdout to file\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cmd >> file";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "   Append stdout to file\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cmd 2> file";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "   Write stderr to file\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cmd 2>&1";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Redirect stderr to stdout\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cmd &> file";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "   Redirect both to file\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  cmd | cmd";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "     Pipe output to next command\n";

        std::cout << "\n  System Information:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  wsltest";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "       Test WSL Kernel Access\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  uptime";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "        Show system uptime\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  free";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Show free and used memory\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lsmem";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Memory information\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lscpu";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         CPU information\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lshw";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Hardware overview (sysinfo)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  df/lsblk";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Disk usage and mounts\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lsusb";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         USB devices\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lsnet";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "         Network interfaces\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  uname -a";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      System information\n";

        std::cout << "\n  Networking:\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  ifconfig/ip";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "   Show network interfaces\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  hostname";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Show hostname (-i for IP)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  ping";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Ping a host (-c count)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  traceroute";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "    Trace route to host\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  nslookup/dig";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "  DNS lookup with server info\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  curl/wget";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "     HTTP requests / download files\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  arp";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "           Show ARP table\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  ss/netstat";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "    Socket statistics (-t tcp, -u udp)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  nc/netcat";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "     TCP client/server (-l listen)\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  net";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "            Network services & WiFi management\n";

        std::cout << "\n  Process Management (Extended):\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  pstree";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "        Show process tree\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  renice/nice";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "   Change process priority\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  lsof";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          List open files/handles\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "\n  External tools: git, node, python, gcc, g++, make, etc.\n";
        std::cout << "  Run 'registry refresh' to scan for installed commands.\n";

        std::cout << "\n";
        SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
        std::cout << "Task Scheduler (Cron):\n";
        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  crontab -l";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      List scheduled tasks\n";
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  crontab -e";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Edit crontab in lino\n";
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  crontab -r";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Remove all scheduled tasks\n";
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  setup cron";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "      Verify/fix cron daemon config\n";
        
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "  Cron runs at system boot. Format: min hour day month weekday cmd\n";
        std::cout << "  Special: @reboot @hourly @daily @weekly @monthly @yearly\n";
        
        std::cout << "\n";
        SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        std::cout << "  exit";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "          Exit the shell\n\n";

        SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
        std::cout << "Setup:\n";
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        std::cout << "  Run 'setup install' to register .sh files with Windows.\n\n";
    }

    // Setup command - register file associations
    void cmdSetup(const std::vector<std::string>& args) {
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        
        if (args.size() < 2) {
            std::cout << "Setup Commands:\n";
            std::cout << "  setup install      Register .sh files with Windows (requires admin)\n";
            std::cout << "  setup uninstall    Remove .sh file association\n";
            std::cout << "  setup status       Check current file association\n";
            std::cout << "  setup admin        Enable sudo command for Windows (requires admin)\n";
            std::cout << "  setup cron         Configure cron daemon (auto-start at boot)\n";
            std::cout << "  setup windux       Add 'Open in Windux' to Explorer right-click menu\n";
            std::cout << "  setup integrate    Install WSL kernel proxy for extended features\n";
            std::cout << "  setup defaultshell Make Linuxify the default system shell\n";
            std::cout << "  setup comment-on   Revert MinGW to original (undo no-comments)\n";
            return;
        }
        
        std::string action = args[1];
        
        // Get path to lish.exe and current exe
        char exePath[MAX_PATH];
        GetModuleFileNameA(NULL, exePath, MAX_PATH);
        fs::path lishPath = fs::path(exePath).parent_path() / "cmds" / "lish.exe";
        
        // Check if ctx.running as admin - ALL setup commands require admin
        {
            BOOL isAdmin = FALSE;
            PSID adminGroup = NULL;
            SID_IDENTIFIER_AUTHORITY ntAuthority = SECURITY_NT_AUTHORITY;
            
            if (AllocateAndInitializeSid(&ntAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID,
                DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &adminGroup)) {
                CheckTokenMembership(NULL, adminGroup, &isAdmin);
                FreeSid(adminGroup);
            }
            
            if (!isAdmin) {
                std::cout << "Administrator privileges required. Requesting elevation...\n";
                
                // Build command line for elevated process
                std::string params = "-c \"setup " + action + "\"";
                
                SHELLEXECUTEINFOA sei = { sizeof(sei) };
                sei.lpVerb = "runas";
                sei.lpFile = exePath;
                sei.lpParameters = params.c_str();
                sei.hwnd = NULL;
                sei.nShow = SW_SHOWNORMAL;
                sei.fMask = SEE_MASK_NOCLOSEPROCESS;
                
                if (ShellExecuteExA(&sei)) {
                    // Wait for elevated process to complete
                    if (sei.hProcess) {
                        WaitForSingleObject(sei.hProcess, INFINITE);
                        CloseHandle(sei.hProcess);
                    }
                    std::cout << "\nSetup completed. You may need to restart your terminal.\n";
                } else {
                    printError("Failed to get administrator privileges.");
                }
                return;
            }
        }
        
        if (action == "install") {
            if (!fs::exists(lishPath)) {
                printError("lish.exe not found at: " + lishPath.string());
                return;
            }
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Registering .sh files with Linuxify Shell...\n";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            
            // Create file type using native Registry API
            std::string ftypeValue = "\"" + lishPath.string() + "\" \"%1\" %*";
            
            // Set ftype: HKEY_CLASSES_ROOT\LishScript\shell\open\command
            HKEY hKey;
            bool result1 = false, result2 = false;
            
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, "LishScript\\shell\\open\\command", 0, NULL, 
                                REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                result1 = (RegSetValueExA(hKey, NULL, 0, REG_SZ, 
                           (BYTE*)ftypeValue.c_str(), (DWORD)ftypeValue.length() + 1) == ERROR_SUCCESS);
                RegCloseKey(hKey);
            }
            
            // Set assoc: HKEY_CLASSES_ROOT\.sh -> LishScript
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, ".sh", 0, NULL,
                                REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                std::string assocValue = "LishScript";
                result2 = (RegSetValueExA(hKey, NULL, 0, REG_SZ,
                           (BYTE*)assocValue.c_str(), (DWORD)assocValue.length() + 1) == ERROR_SUCCESS);
                RegCloseKey(hKey);
            }

            // Set assoc: HKEY_CLASSES_ROOT\.lin -> LishScript
            bool resultLin = false;
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, ".lin", 0, NULL,
                                REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                std::string assocValue = "LishScript";
                resultLin = (RegSetValueExA(hKey, NULL, 0, REG_SZ,
                           (BYTE*)assocValue.c_str(), (DWORD)assocValue.length() + 1) == ERROR_SUCCESS);
                RegCloseKey(hKey);
            }
            
            // Add .SH to PATHEXT for PowerShell compatibility
            std::cout << "Adding .SH to PATHEXT for PowerShell...\n";
            
            // Check if .SH is already in PATHEXT
            const char* pathext = getenv("PATHEXT");
            
            bool needsPathext = true;
            if (pathext) {
                std::string pathextStr = pathext;
                std::transform(pathextStr.begin(), pathextStr.end(), pathextStr.begin(), ::toupper);
                if (pathextStr.find(".SH") != std::string::npos && pathextStr.find(".LIN") != std::string::npos) {
                    needsPathext = false;
                    std::cout << ".SH and .LIN already in PATHEXT\n";
                }
            }
            
            int result3 = 0;
            if (needsPathext) {
                // Add .SH to system PATHEXT using native Registry API
                HKEY hEnvKey;
                if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, 
                    "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment",
                    0, KEY_READ | KEY_WRITE, &hEnvKey) == ERROR_SUCCESS) {
                    
                    char pathextBuf[4096];
                    DWORD pathextSize = sizeof(pathextBuf);
                    DWORD pathextType;
                    
                    if (RegQueryValueExA(hEnvKey, "PATHEXT", NULL, &pathextType, 
                        (BYTE*)pathextBuf, &pathextSize) == ERROR_SUCCESS) {
                        
                        std::string currentPathExt = pathextBuf;
                        std::string currentPathExtUpper = currentPathExt;
                        std::transform(currentPathExtUpper.begin(), currentPathExtUpper.end(), currentPathExtUpper.begin(), ::toupper);
                        
                        std::string newPathext = currentPathExt;
                        
                        if (currentPathExtUpper.find(".SH") == std::string::npos) {
                            newPathext += ";.SH";
                        }
                        
                        if (currentPathExtUpper.find(".LIN") == std::string::npos) {
                            newPathext += ";.LIN";
                        }
                        
                        if (RegSetValueExA(hEnvKey, "PATHEXT", 0, pathextType,
                            (BYTE*)newPathext.c_str(), (DWORD)newPathext.length() + 1) == ERROR_SUCCESS) {
                            result3 = 0;
                        } else {
                            result3 = 1;
                        }
                    }
                    RegCloseKey(hEnvKey);
                }
            }
            
            if (result1 && result2) {
                SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "\nSuccess! .sh and .lin files are now associated with lish.exe\n";
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                std::cout << "\nHow to run scripts:\n";
                std::cout << "  From cmd:         script.sh  or  script.lin\n";
                std::cout << "  From PowerShell:  lish script.sh\n";
                std::cout << "  Double-click:     Works in Explorer\n";
                std::cout << "  From Linuxify:    ./script.sh\n";
                std::cout << "\nNote: Scripts must have a shebang (e.g., #!lish)\n";
                if (needsPathext && result3 == 0) {
                    std::cout << "\nRestart your terminal for PATHEXT changes to take effect.\n";
                }
            } else {
                printError("Failed to register. Try running as Administrator.");
            }
            
        } else if (action == "uninstall") {
            std::cout << "Removing .sh/.lin file association...\n";
            
            // Remove .sh/.lin association using native Registry API
            RegDeleteTreeA(HKEY_CLASSES_ROOT, ".sh");
            RegDeleteTreeA(HKEY_CLASSES_ROOT, ".lin");
            RegDeleteTreeA(HKEY_CLASSES_ROOT, "LishScript");
            
            printSuccess("File association removed.");
            std::cout << "\nNote: .SH was added to PATHEXT. To remove it:\n";
            std::cout << "  1. Open System Properties > Environment Variables\n";
            std::cout << "  2. Edit PATHEXT and remove ;.SH\n";
            
        } else if (action == "status") {
            std::cout << "Checking .sh file association...\n\n";
            
            // Check current association using native Registry API
            HKEY hKey;
            char valueBuf[512];
            DWORD valueSize = sizeof(valueBuf);
            
            if (RegOpenKeyExA(HKEY_CLASSES_ROOT, ".sh", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
                if (RegQueryValueExA(hKey, NULL, NULL, NULL, (BYTE*)valueBuf, &valueSize) == ERROR_SUCCESS) {
                    std::cout << ".sh=" << valueBuf << "\n";
                }
                RegCloseKey(hKey);
            } else {
                std::cout << ".sh association not found\n";
            }

            valueSize = sizeof(valueBuf);
            if (RegOpenKeyExA(HKEY_CLASSES_ROOT, ".lin", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
                if (RegQueryValueExA(hKey, NULL, NULL, NULL, (BYTE*)valueBuf, &valueSize) == ERROR_SUCCESS) {
                    std::cout << ".lin=" << valueBuf << "\n";
                }
                RegCloseKey(hKey);
            } else {
                std::cout << ".lin association not found\n";
            }
            
            valueSize = sizeof(valueBuf);
            if (RegOpenKeyExA(HKEY_CLASSES_ROOT, "LishScript\\shell\\open\\command", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
                if (RegQueryValueExA(hKey, NULL, NULL, NULL, (BYTE*)valueBuf, &valueSize) == ERROR_SUCCESS) {
                    std::cout << "LishScript=" << valueBuf << "\n";
                }
                RegCloseKey(hKey);
            } else {
                std::cout << "LishScript not registered\n";
            }
            
            std::cout << "\nlish.exe location: " << lishPath.string() << "\n";
            std::cout << "Exists: " << (fs::exists(lishPath) ? "Yes" : "No") << "\n";
        } else if (action == "admin") {
            // Enable Windows 11 native sudo command
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Enabling Windows 11 native sudo...\n";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            
            // Check Windows version first
            std::cout << "Checking Windows version...\n";
            
            // Enable sudo in normal mode (runs in same terminal, allows input)
            // This requires Windows 11 24H2 or later
            std::cout << "Running: sudo config --enable normal\n";
            int result = runProcess("sudo config --enable normal");
            
            if (result == 0) {
                SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "\nSuccess! Windows sudo is now enabled.\n";
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                std::cout << "\nThis means sudo commands run in the SAME terminal window!\n";
                std::cout << "\nUsage:\n";
                std::cout << "  From cmd:         sudo <command>\n";
                std::cout << "  From PowerShell:  sudo <command>\n";
                std::cout << "  From Linuxify:    sudo <command>\n";
                std::cout << "\nExamples:\n";
                std::cout << "  sudo notepad C:\\Windows\\System32\\drivers\\etc\\hosts\n";
                std::cout << "  sudo netsh wlan show profiles\n";
                std::cout << "  sudo ln -s source.txt link.txt\n";
            } else {
                printError("Failed to enable sudo.");
                std::cout << "\nPossible causes:\n";
                std::cout << "  1. Windows 11 version 24H2 or later is required\n";
                std::cout << "  2. You may need to update Windows\n";
                std::cout << "  3. Run 'winver' to check your Windows version\n";
                std::cout << "\nAlternatively, you can enable it manually:\n";
                std::cout << "  Settings > System > For Developers > Enable sudo\n";
            }
            
            
        } else if (action == "comment-on") {
            std::cout << "Restoring original MinGW DLLs (Reverting No-Comment Policy)...\n";
            
            fs::path cmdsSrcPath = fs::path(exePath).parent_path() / "cmds-src";
            fs::path zlibSource = cmdsSrcPath / "zlib_proxy" / "zlib1.dll";
            fs::path iconvSource = cmdsSrcPath / "zlib_proxy" / "libiconv-2.dll";
            
            std::string mingwBinPath = "C:\\mingw64\\mingw64\\bin";
            fs::path zlibTarget = fs::path(mingwBinPath) / "zlib1.dll";
            fs::path iconvTarget = fs::path(mingwBinPath) / "libiconv-2.dll";
            
            if (!fs::exists(mingwBinPath)) {
                printError("MinGW bin directory not found at: " + mingwBinPath);
                return;
            }
            
            bool success = true;
            
            // Restore zlib1.dll
            if (fs::exists(zlibSource)) {
                try {
                    fs::copy_file(zlibSource, zlibTarget, fs::copy_options::overwrite_existing);
                    std::cout << "Restored zlib1.dll\n";
                } catch (const std::exception& e) {
                    printError("Failed to restore zlib1.dll: " + std::string(e.what()));
                    success = false;
                }
            } else {
                printError("Original zlib1.dll not found at: " + zlibSource.string());
                success = false;
            }
            
            // Restore libiconv-2.dll
            if (fs::exists(iconvSource)) {
                try {
                    fs::copy_file(iconvSource, iconvTarget, fs::copy_options::overwrite_existing);
                    std::cout << "Restored libiconv-2.dll\n";
                } catch (const std::exception& e) {
                    printError("Failed to restore libiconv-2.dll: " + std::string(e.what()));
                    success = false;
                }
            } else {
                printError("Original libiconv-2.dll not found at: " + iconvSource.string());
                success = false;
            }
            
            if (success) {
                printSuccess("MinGW reverted to original state. Comments are now allowed.");
            }
            
        } else if (action == "cron") {
            // Setup/verify cron daemon
            std::cout << "Checking cron daemon configuration...\n\n";
            
            char exePath[MAX_PATH];
            GetModuleFileNameA(NULL, exePath, MAX_PATH);
            fs::path crondPath = fs::path(exePath).parent_path() / "cmds" / "crond.exe";
            fs::path crontabPath = fs::path(getLinuxdbPath()) / "crontab";
            
            bool allGood = true;
            
            // 1. Check if crond.exe exists
            std::cout << "[1/4] Checking crond.exe... ";
            if (fs::exists(crondPath)) {
                std::cout << "\033[32mOK\033[0m\n";
            } else {
                std::cout << "\033[31mMISSING\033[0m\n";
                printError("crond.exe not found at: " + crondPath.string());
                allGood = false;
            }
            
            // 2. Check if crontab exists
            std::cout << "[2/4] Checking crontab file... ";
            if (fs::exists(crontabPath)) {
                std::cout << "\033[32mOK\033[0m\n";
            } else {
                std::cout << "\033[33mCREATING\033[0m\n";
                // Create default crontab
                fs::create_directories(crontabPath.parent_path());
                std::ofstream file(crontabPath);
                file << "# Linuxify Crontab\n";
                file << "# Format: min hour day month weekday command\n";
                file << "# Special: @reboot @hourly @daily @weekly @monthly @yearly\n\n";
                std::cout << "  Created: " << crontabPath.string() << "\n";
            }
            
            // 3. Check if crond is registered to start at system boot
            std::cout << "[3/4] Checking system startup registration... ";
            HKEY hKey;
            bool isRegistered = false;
            if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                              "Software\\Microsoft\\Windows\\CurrentVersion\\Run",
                              0, KEY_READ, &hKey) == ERROR_SUCCESS) {
                char value[MAX_PATH];
                DWORD size = sizeof(value);
                isRegistered = RegQueryValueExA(hKey, "LinuxifyCrond", NULL, NULL,
                                                (LPBYTE)value, &size) == ERROR_SUCCESS;
                RegCloseKey(hKey);
            }
            
            if (isRegistered) {
                std::cout << "\033[32mOK\033[0m (starts at system boot)\n";
            } else {
                std::cout << "\033[33mNOT REGISTERED\033[0m\n";
                std::cout << "  Installing crond to start at system boot...\n";
                
                // Register in startup (HKLM requires admin)
                if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                                  "Software\\Microsoft\\Windows\\CurrentVersion\\Run",
                                  0, KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
                    std::string regValue = "\"" + crondPath.string() + "\"";
                    if (RegSetValueExA(hKey, "LinuxifyCrond", 0, REG_SZ,
                                       (const BYTE*)regValue.c_str(),
                                       (DWORD)(regValue.length() + 1)) == ERROR_SUCCESS) {
                        std::cout << "  \033[32mInstalled to system startup\033[0m\n";
                    } else {
                        printError("Failed to register crond (may need admin rights)");
                        allGood = false;
                    }
                    RegCloseKey(hKey);
                } else {
                    printError("Failed to access registry (run as admin)");
                    allGood = false;
                }
            }
            
            // 4. Check if crond is currently ctx.running
            std::cout << "[4/4] Checking if crond is running... ";
            HANDLE hPipe = CreateFileA(
                CROND_PIPE_NAME,
                GENERIC_READ | GENERIC_WRITE,
                0, NULL, OPEN_EXISTING, 0, NULL
            );
            
            if (hPipe != INVALID_HANDLE_VALUE) {
                // Send PING to verify
                const char* msg = "PING";
                DWORD bytesWritten;
                WriteFile(hPipe, msg, (DWORD)strlen(msg), &bytesWritten, NULL);
                
                char response[256];
                DWORD bytesRead;
                if (ReadFile(hPipe, response, sizeof(response) - 1, &bytesRead, NULL) && bytesRead > 0) {
                    std::cout << "\033[32mRUNNING\033[0m\n";
                } else {
                    std::cout << "\033[31mNOT RESPONDING\033[0m\n";
                    allGood = false;
                }
                CloseHandle(hPipe);
            } else {
                std::cout << "\033[33mNOT RUNNING\033[0m\n";
                std::cout << "  Starting crond daemon...\n";
                
                // Start crond in background
                STARTUPINFOA si;
                PROCESS_INFORMATION pi;
                ZeroMemory(&si, sizeof(si));
                si.cb = sizeof(si);
                ZeroMemory(&pi, sizeof(pi));
                
                std::string cmdLine = "\"" + crondPath.string() + "\"";
                char cmdBuffer[1024];
                strncpy_s(cmdBuffer, cmdLine.c_str(), sizeof(cmdBuffer) - 1);
                
                if (CreateProcessA(NULL, cmdBuffer, NULL, NULL, FALSE,
                                   CREATE_NO_WINDOW | DETACHED_PROCESS,
                                   NULL, NULL, &si, &pi)) {
                    CloseHandle(pi.hProcess);
                    CloseHandle(pi.hThread);
                    std::cout << "  \033[32mStarted crond daemon\033[0m\n";
                } else {
                    printError("Failed to start crond daemon");
                    allGood = false;
                }
            }
            
            std::cout << "\n";
            if (allGood) {
                printSuccess("Cron daemon is configured correctly!");
                std::cout << "Use 'crontab -e' to edit scheduled tasks.\n";
            } else {
                printError("Some issues found. Please fix them above.");
            }
            
        } else if (action == "windux") {
            // Add "Open in Windux" to Windows Explorer context menu
            char exePath[MAX_PATH];
            GetModuleFileNameA(NULL, exePath, MAX_PATH);
            fs::path winduxPath = fs::path(exePath).parent_path() / "cmds" / "windux.exe";
            
            if (!fs::exists(winduxPath)) {
                printError("windux.exe not found at: " + winduxPath.string());
                return;
            }
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Adding 'Open in Windux' to Windows Explorer context menu...\n";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            
            std::string winduxCmd = "\"" + winduxPath.string() + "\"";
            bool success = true;
            HKEY hKey;
            
            // 1. Add to Directory Background (right-click in folder empty space)
            std::cout << "[1/3] Directory background context menu... ";
            std::string keyPath1 = "Directory\\Background\\shell\\Windux";
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, keyPath1.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                RegSetValueExA(hKey, NULL, 0, REG_SZ, (const BYTE*)"Open in Windux", 15);
                RegSetValueExA(hKey, "Icon", 0, REG_SZ, (const BYTE*)winduxCmd.c_str(), (DWORD)(winduxCmd.length() + 1));
                RegCloseKey(hKey);
                
                std::string cmdKeyPath = keyPath1 + "\\command";
                if (RegCreateKeyExA(HKEY_CLASSES_ROOT, cmdKeyPath.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                    std::string cmd = winduxCmd + " \"%V\"";
                    RegSetValueExA(hKey, NULL, 0, REG_SZ, (const BYTE*)cmd.c_str(), (DWORD)(cmd.length() + 1));
                    RegCloseKey(hKey);
                    std::cout << "\033[32mOK\033[0m\n";
                } else { std::cout << "\033[31mFAILED\033[0m\n"; success = false; }
            } else { std::cout << "\033[31mFAILED\033[0m\n"; success = false; }
            
            // 2. Add to Desktop Background (right-click on desktop)
            std::cout << "[2/3] Desktop background context menu... ";
            std::string keyPath2 = "DesktopBackground\\shell\\Windux";
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, keyPath2.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                RegSetValueExA(hKey, NULL, 0, REG_SZ, (const BYTE*)"Open in Windux", 15);
                RegSetValueExA(hKey, "Icon", 0, REG_SZ, (const BYTE*)winduxCmd.c_str(), (DWORD)(winduxCmd.length() + 1));
                RegCloseKey(hKey);
                
                std::string cmdKeyPath = keyPath2 + "\\command";
                if (RegCreateKeyExA(HKEY_CLASSES_ROOT, cmdKeyPath.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                    std::string cmd = winduxCmd + " \"%V\"";
                    RegSetValueExA(hKey, NULL, 0, REG_SZ, (const BYTE*)cmd.c_str(), (DWORD)(cmd.length() + 1));
                    RegCloseKey(hKey);
                    std::cout << "\033[32mOK\033[0m\n";
                } else { std::cout << "\033[31mFAILED\033[0m\n"; success = false; }
            } else { std::cout << "\033[31mFAILED\033[0m\n"; success = false; }
            
            // 3. Add to Folder context menu (right-click on a folder)
            std::cout << "[3/3] Folder context menu... ";
            std::string keyPath3 = "Directory\\shell\\Windux";
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, keyPath3.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                RegSetValueExA(hKey, NULL, 0, REG_SZ, (const BYTE*)"Open in Windux", 15);
                RegSetValueExA(hKey, "Icon", 0, REG_SZ, (const BYTE*)winduxCmd.c_str(), (DWORD)(winduxCmd.length() + 1));
                RegCloseKey(hKey);
                
                std::string cmdKeyPath = keyPath3 + "\\command";
                if (RegCreateKeyExA(HKEY_CLASSES_ROOT, cmdKeyPath.c_str(), 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                    std::string cmd = winduxCmd + " \"%V\"";
                    RegSetValueExA(hKey, NULL, 0, REG_SZ, (const BYTE*)cmd.c_str(), (DWORD)(cmd.length() + 1));
                    RegCloseKey(hKey);
                    std::cout << "\033[32mOK\033[0m\n";
                } else { std::cout << "\033[31mFAILED\033[0m\n"; success = false; }
            } else { std::cout << "\033[31mFAILED\033[0m\n"; success = false; }
            
            std::cout << "\n";
            if (success) {
                printSuccess("'Open in Windux' added to Explorer context menu!");
                std::cout << "Right-click in Explorer to see the option.\n";
            } else {
                printError("Some entries failed. Try ctx.running as Administrator.");
            }
            
        } else if (action == "integrate") {
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Installing WSL Kernel Proxy...\n";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            
            char exePathBuf[MAX_PATH];
            GetModuleFileNameA(NULL, exePathBuf, MAX_PATH);
            fs::path proxyDll = fs::path(exePathBuf).parent_path() / "cmds-src" / "wsl_proxy" / "wslapi.dll";
            
            if (!fs::exists(proxyDll)) {
                printError("Proxy DLL not found. Build it first with:");
                std::cout << "  cd cmds-src/wsl_proxy\n";
                std::cout << "  g++ -shared -o wslapi.dll wslapi.cpp wslapi.def -lntdll\n";
                return;
            }
            
            WCHAR systemPath[MAX_PATH];
            GetSystemDirectoryW(systemPath, MAX_PATH);
            fs::path origDll = fs::path(systemPath) / "wslapi.dll";
            fs::path backupDll = fs::path(systemPath) / "wslapi_orig.dll";
            
            std::cout << "[1/3] Checking existing WSL API...\n";
            if (!fs::exists(origDll)) {
                printError("wslapi.dll not found in System32. WSL may not be installed.");
                return;
            }
            
            std::cout << "[2/3] Backing up original DLL...\n";
            if (!fs::exists(backupDll)) {
                try {
                    fs::copy_file(origDll, backupDll);
                    std::cout << "  Backed up to: " << backupDll.string() << "\n";
                } catch (const std::exception& e) {
                    printError(std::string("Failed to backup: ") + e.what());
                    return;
                }
            } else {
                std::cout << "  Backup already exists\n";
            }
            
            std::cout << "[3/3] Installing proxy DLL...\n";
            try {
                fs::copy_file(proxyDll, origDll, fs::copy_options::overwrite_existing);
                printSuccess("WSL Kernel Proxy installed!");
                std::cout << "\nRun 'wsltest' to verify kernel access.\n";
            } catch (const std::exception& e) {
                printError(std::string("Failed to install: ") + e.what());
                std::cout << "The file may be in use. Try:\n";
                std::cout << "  1. Close all WSL/Linux processes\n";
                std::cout << "  2. Run: wsl --shutdown\n";
                std::cout << "  3. Try again\n";
            }
            
        } else if (action == "defaultshell") {
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "Setting Linuxify as Default Shell...\n";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            
            char exePathBuf[MAX_PATH];
            GetModuleFileNameA(NULL, exePathBuf, MAX_PATH);
            std::string linuxifyPath = exePathBuf;
            
            bool allSuccess = true;
            
            std::cout << "[1/3] Setting ComSpec environment variable...\n";
            HKEY hEnvKey;
            long regResult = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment",
                0, KEY_SET_VALUE | KEY_QUERY_VALUE, &hEnvKey);

            if (regResult == ERROR_SUCCESS) {
                if (RegSetValueExA(hEnvKey, "ComSpec", 0, REG_SZ,
                    (const BYTE*)linuxifyPath.c_str(),
                    (DWORD)(linuxifyPath.length() + 1)) == ERROR_SUCCESS) {
                    
                    // Verify the write
                    char verifyBuf[MAX_PATH];
                    DWORD verifySize = sizeof(verifyBuf);
                    if (RegQueryValueExA(hEnvKey, "ComSpec", NULL, NULL, (LPBYTE)verifyBuf, &verifySize) == ERROR_SUCCESS) {
                         if (linuxifyPath == verifyBuf) {
                             std::cout << "  \033[32mOK\033[0m ComSpec -> " << linuxifyPath << "\n";
                         } else {
                             printError("Verification failed: ComSpec mismatch");
                             allSuccess = false;
                         }
                    } else {
                        printError("Verification failed: Could not read back ComSpec");
                         allSuccess = false;
                    }
                } else {
                    printError("Failed to set ComSpec (RegSetValueExA failed)");
                    allSuccess = false;
                }
                RegCloseKey(hEnvKey);
            } else {
                printError("Failed to open environment registry (Error: " + std::to_string(regResult) + ")");
                std::cout << "  Make sure you are running as Administrator.\n";
                allSuccess = false;
            }
            
            std::cout << "[2/3] Setting as Windows Terminal default...\n";
            std::string settingsPath = std::string(getenv("LOCALAPPDATA")) + 
                "\\Packages\\Microsoft.WindowsTerminal_8wekyb3d8bbwe\\LocalState\\settings.json";
            
            if (fs::exists(settingsPath)) {
                try {
                    std::ifstream inFile(settingsPath);
                    std::string content((std::istreambuf_iterator<char>(inFile)),
                                        std::istreambuf_iterator<char>());
                    inFile.close();
                    
                    size_t defaultPos = content.find("\"defaultProfile\"");
                    if (defaultPos != std::string::npos) {
                        size_t guidStart = content.find("\"", defaultPos + 16);
                        size_t guidEnd = content.find("\"", guidStart + 1);
                        if (guidStart != std::string::npos && guidEnd != std::string::npos) {
                            size_t linuxifyPos = content.find("\"name\": \"Linuxify\"");
                            if (linuxifyPos != std::string::npos) {
                                size_t guidSearchStart = linuxifyPos;
                                while (guidSearchStart > 0 && content[guidSearchStart] != '{') guidSearchStart--;
                                size_t lgStart = content.rfind("\"guid\":", linuxifyPos);
                                if (lgStart != std::string::npos) {
                                    size_t lgGuidStart = content.find("\"", lgStart + 7);
                                    size_t lgGuidEnd = content.find("\"", lgGuidStart + 1);
                                    std::string linuxifyGuid = content.substr(lgGuidStart, lgGuidEnd - lgGuidStart + 1);
                                    content.replace(guidStart, guidEnd - guidStart + 1, linuxifyGuid);
                                    
                                    std::ofstream outFile(settingsPath);
                                    outFile << content;
                                    outFile.close();
                                    std::cout << "  Windows Terminal default set to Linuxify\n";
                                }
                            } else {
                                std::cout << "  Linuxify profile not found in Terminal. Run installer first.\n";
                            }
                        }
                    }
                } catch (...) {
                    std::cout << "  Could not modify Windows Terminal settings\n";
                }
            } else {
                std::cout << "  Windows Terminal not installed (optional)\n";
            }
            
            std::cout << "[3/3] Setting 'Open command window here' to Linuxify...\n";
            HKEY hKey;
            std::string cmdPath = "\"" + linuxifyPath + "\"";
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, 
                "Directory\\Background\\shell\\cmd\\command", 0, NULL, 0,
                KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                RegSetValueExA(hKey, NULL, 0, REG_SZ, 
                    (const BYTE*)cmdPath.c_str(), (DWORD)(cmdPath.length() + 1));
                RegCloseKey(hKey);
                std::cout << "  Explorer 'Open command window here' -> Linuxify\n";
            }
            
            if (RegCreateKeyExA(HKEY_CLASSES_ROOT, 
                "Directory\\shell\\cmd\\command", 0, NULL, 0,
                KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
                std::string cmdWithDir = cmdPath;
                RegSetValueExA(hKey, NULL, 0, REG_SZ, 
                    (const BYTE*)cmdWithDir.c_str(), (DWORD)(cmdWithDir.length() + 1));
                RegCloseKey(hKey);
            }
            
            std::cout << "\n";
            if (allSuccess) {
                printSuccess("Linuxify is now the default shell!");
                std::cout << "Changes take effect after:\n";
                std::cout << "  - Log out and back in, OR\n";
                std::cout << "  - Restart Explorer (taskkill /f /im explorer.exe && explorer)\n";
                std::cout << "\nTo revert: set ComSpec back to C:\\Windows\\system32\\cmd.exe\n";
            }
            
        } else {
            printError("Unknown setup action: " + action);
        }
    }

    void runFuzzer(const std::vector<std::string>& args) {
        int iterations = 100;
        if (args.size() > 1) {
            try {
                iterations = std::stoi(args[1]);
            } catch (...) {
                printError("Invalid iteration count. Defaulting to 100.");
            }
        }
        
        Linuxify::ShellFuzzer fuzzer;
        fuzzer.run(iterations, [this](std::string cmd) {
            // Silence standard output during fuzzing to avoid spam
            // but for now we keep it visible to demonstrate activity
            this->executeCommandLine(cmd); 
        });
    }

    void executeCommand(const std::vector<std::string>& tokens) {
        if (tokens.empty()) {
            return;
        }

        std::vector<std::string> expandedTokens = expandTokens(tokens);
        const std::string& cmd = expandedTokens[0];
        ctx.lastExitCode = 0;

        std::string fullInput;
        for (size_t i = 0; i < expandedTokens.size(); i++) {
            if (i > 0) fullInput += " ";
            fullInput += expandedTokens[i];
        }
        if (Arith::isArithmeticExpression(fullInput)) {
            try {
                std::string result = Arith::evaluate(fullInput);
                std::cout << result << std::endl;
                return;
            } catch (const std::exception& e) {
            }
        }

        try {
        if (cmd == "pwd") {
            cmdPwd(expandedTokens);
        } else if (cmd == "cd") {
            cmdCd(expandedTokens);

        } else if (cmd == "clear") {
            cmdClear(expandedTokens);
        } else if (cmd == "help") {
            cmdHelp(expandedTokens);
        } else if (cmd == "fuzz") {
            runFuzzer(expandedTokens);
        } else if (cmd == "lino") {
            std::string linoCmd = "lino.exe";
            if (expandedTokens.size() > 1) {
                linoCmd += " \"" + resolvePath(expandedTokens[1]) + "\"";
            }
            runProcess(linoCmd);
        } else if (cmd == "lin") {
            cmdLin(expandedTokens);
        } else if (cmd == "setup") {
            cmdSetup(expandedTokens);
        } else if (cmd == "alias") {
            cmdAlias(expandedTokens);
        } else if (cmd == "unalias") {
            cmdUnalias(expandedTokens);
        } else if (cmd == "wsltest") {
            HANDLE hCon = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(hCon, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "WSL Kernel Access Test\n";
            SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            std::cout << std::string(40, '=') << "\n\n";
            
            std::cout << "[1] Proxy Status: ";
            if (LxssKernel::IsWslProxyInstalled()) {
                std::string ver = LxssKernel::GetProxyVersion();
                SetConsoleTextAttribute(hCon, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "ACTIVE";
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                if (!ver.empty()) std::cout << " (v" << ver << ")";
                std::cout << "\n";
            } else {
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_INTENSITY);
                std::cout << "NOT INSTALLED";
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                std::cout << " - Run 'setup integrate'\n";
            }
            
            std::cout << "[2] LXSS Driver: ";
            if (LxssKernel::IsLxcoreDriverLoaded()) {
                SetConsoleTextAttribute(hCon, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "LOADED\n";
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            } else {
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_INTENSITY);
                std::cout << "NOT FOUND\n";
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            }
            
            std::cout << "[3] Kernel Device: ";
            LxssKernel::LxssDevice device;
            if (device.Open()) {
                SetConsoleTextAttribute(hCon, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "OPEN";
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                std::cout << " (\\Device\\lxss)\n";
                
                std::cout << "[4] Subsystem Query: ";
                LxssKernel::SubsystemInfo info = device.QuerySubsystem();
                if (info.available) {
                    SetConsoleTextAttribute(hCon, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    std::cout << "SUCCESS\n";
                    SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                } else {
                    SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    std::cout << "IOCTL FAILED";
                    SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                    std::cout << " (Error: " << device.GetLastError() << ")\n";
                }
            } else {
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_INTENSITY);
                std::cout << "FAILED";
                SetConsoleTextAttribute(hCon, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                std::cout << " (Error: " << device.GetLastError() << ")\n";
                std::cout << "  Note: WSL must be installed and enabled\n";
            }
            
            std::cout << "\n";
        } else if (cmd == "registry") {
            // Registry management commands
            if (expandedTokens.size() > 1 && expandedTokens[1] == "refresh") {
                HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
                SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "Scanning for installed commands...";
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                
                int found = g_registry.refreshRegistry();
                std::cout << " found " << found << " commands.\n";
                printSuccess("Registry updated! Use 'registry list' to see all commands.");
            } else if (expandedTokens.size() > 1 && expandedTokens[1] == "list") {
                const auto& commands = g_registry.getAllCommands();
                HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
                SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                std::cout << "Registered External Commands";
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                std::cout << " (" << commands.size() << " total)\n\n";
                
                for (const auto& pair : commands) {
                    SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    std::cout << std::setw(15) << std::left << pair.first;
                    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                    std::cout << " -> " << pair.second << "\n";
                }
            } else if (expandedTokens.size() > 3 && expandedTokens[1] == "add") {
                g_registry.addCommand(expandedTokens[2], expandedTokens[3]);
                printSuccess("Added: " + expandedTokens[2] + " -> " + expandedTokens[3]);
                std::cout << "Saved to: " << g_registry.getDbPath() << std::endl;
            } else if (expandedTokens.size() > 2 && (expandedTokens[1] == "delete" || expandedTokens[1] == "remove" || expandedTokens[1] == "rm")) {
                g_registry.removeCommand(expandedTokens[2]);
                printSuccess("Removed: " + expandedTokens[2]);
            } else if (expandedTokens.size() > 3 && expandedTokens[1] == "switch") {
                std::string cmdName = expandedTokens[2];
                std::string newPath = resolvePath(expandedTokens[3]);
                
                if (!g_registry.isRegistered(cmdName)) {
                    printError("registry: command '" + cmdName + "' not found in registry");
                } else if (!fs::exists(newPath)) {
                    printError("registry: path '" + newPath + "' does not exist");
                } else {
                    g_registry.addCommand(cmdName, newPath);
                    printSuccess("Switched: " + cmdName + " -> " + newPath);
                }
            } else {
                std::cout << "Registry Commands:\n";
                std::cout << "  registry refresh              Scan system for installed commands\n";
                std::cout << "  registry list                 Show all registered commands\n";
                std::cout << "  registry add <cmd> <path>     Add custom command\n";
                std::cout << "  registry delete <cmd>         Remove a command\n";
                std::cout << "  registry switch <cmd> <path>  Change path of existing command\n";
            }
        } else if (cmd == "history") {
            cmdHistory(expandedTokens);

        } else if (cmd == "echo") {
            cmdEcho(expandedTokens);
        } else if (cmd == "env" || cmd == "printenv") {
            cmdEnv(expandedTokens);
        } else if (cmd == "export") {
            cmdExport(expandedTokens);
        } else if (cmd == "which" || cmd == "where") {
            cmdWhich(expandedTokens);

        } else if (cmd == "jobs") {
            cmdJobs(expandedTokens);
        } else if (cmd == "fg") {
            cmdFg(expandedTokens);
        } else if (cmd == "bg") {
            cmdBg(expandedTokens);

        } else if (cmd == "lscpu") {
            SystemInfo::listCPU();
        } else if (cmd == "lshw" || cmd == "sysinfo") {
            SystemInfo::listHardware();

        } else if (cmd == "lsusb") {
            SystemInfo::listUSB();
        } else if (cmd == "lsnet") {
            SystemInfo::listNetwork();
        } else if (cmd == "lsof") {
            SystemInfo::listOpenFiles();

        } else if (cmd == "ping") {
            Networking::ping(expandedTokens);
        } else if (cmd == "traceroute" || cmd == "tracert") {
            Networking::traceroute(expandedTokens);
        } else if (cmd == "nslookup") {
            Networking::nslookup(expandedTokens);
        } else if (cmd == "dig" || cmd == "host") {
            Networking::dig(expandedTokens);
        } else if (cmd == "wget") {
            Networking::wget(expandedTokens, ctx.currentDir);
        } else if (cmd == "netstat") {
            Networking::netstat(expandedTokens);
        } else if (cmd == "ifconfig" || cmd == "ipconfig") {
            Networking::ifconfig(expandedTokens);
        } else if (cmd == "ss") {
            Networking::ss(expandedTokens);

        } else if (cmd == "arp") {
            Networking::arp(expandedTokens);
        } else if (cmd == "nc" || cmd == "netcat") {
            Networking::nc(expandedTokens);
        } else if (cmd == "pstree") {
            DWORD pid = 0;
            if (expandedTokens.size() > 1) { try { pid = std::stoul(expandedTokens[1]); } catch (...) {} }
            ProcessManager::pstree(pid);
        } else if (cmd == "renice" || cmd == "nice") {
            if (expandedTokens.size() < 3) {
                printError("Usage: renice <priority> -p <pid>");
            } else {
                int priority = 0;
                DWORD pid = 0;
                for (size_t i = 1; i < expandedTokens.size(); i++) {
                    if (expandedTokens[i] == "-p" && i + 1 < expandedTokens.size()) {
                        try { pid = std::stoul(expandedTokens[++i]); } catch (...) {}
                    } else if (expandedTokens[i] == "-n" && i + 1 < expandedTokens.size()) {
                        try { priority = std::stoi(expandedTokens[++i]); } catch (...) {}
                    } else {
                        try { priority = std::stoi(expandedTokens[i]); } catch (...) {}
                    }
                }
                if (pid > 0 && ProcessManager::setProcessPriority(pid, priority)) {
                    std::cout << "Priority of PID " << pid << " set to " << priority << std::endl;
                } else {
                    printError("Failed to set priority");
                }
            }

        } else if (cmd == "sudo") {
            if (expandedTokens.size() < 2) {
                std::cout << "Usage: sudo <command> [arguments]\n";
                std::cout << "Run a command with administrator privileges.\n";
                std::cout << "\nNote: Requires Windows 11 24H2+ with sudo enabled.\n";
                std::cout << "Run 'setup admin' to enable sudo on your system.\n";
                std::cout << "\nExamples:\n";
                std::cout << "  sudo notepad C:\\Windows\\System32\\drivers\\etc\\hosts\n";
                std::cout << "  sudo netsh wlan show profiles\n";
                std::cout << "  sudo ln -s source.txt link.txt\n";
            } else {
                std::string targetCmd = expandedTokens[1];
                bool isBuiltin = isBuiltinCommand(targetCmd);
                
                char exePath[MAX_PATH];
                GetModuleFileNameA(NULL, exePath, MAX_PATH);
                fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
                bool isInCmds = false;
                std::vector<std::string> exts = {".exe", ".cmd", ".bat", ""};
                for (const auto& ext : exts) {
                    if (fs::exists(cmdsDir / (targetCmd + ext))) {
                        isInCmds = true;
                        break;
                    }
                }
                
                std::string sudoCmd;
                if (isBuiltin || isInCmds) {
                    sudoCmd = "sudo \"" + std::string(exePath) + "\" -c \"";
                    for (size_t i = 1; i < expandedTokens.size(); i++) {
                        if (i > 1) sudoCmd += " ";
                        std::string arg = expandedTokens[i];
                        if (arg.find(' ') != std::string::npos || arg.find('"') != std::string::npos) {
                            sudoCmd += "'" + arg + "'";
                        } else {
                            sudoCmd += arg;
                        }
                    }
                    sudoCmd += "\"";
                } else {
                    sudoCmd = "sudo";
                    for (size_t i = 1; i < expandedTokens.size(); i++) {
                        sudoCmd += " ";
                        if (expandedTokens[i].find(' ') != std::string::npos) {
                            sudoCmd += "\"" + expandedTokens[i] + "\"";
                        } else {
                            sudoCmd += expandedTokens[i];
                        }
                    }
                }
                
                int result = runProcess(sudoCmd);
                if (result != 0) {
                    printError("sudo command failed. Make sure sudo is enabled:");
                    std::cout << "  Run 'setup admin' or enable in Settings > For Developers\n";
                }
            }
        } else if (cmd == "crontab") {
            auto sendToCrond = [](const char* command) -> std::string {
                HANDLE hPipe = CreateFileA(
                    CROND_PIPE_NAME,
                    GENERIC_READ | GENERIC_WRITE,
                    0, NULL, OPEN_EXISTING, 0, NULL
                );
                
                if (hPipe == INVALID_HANDLE_VALUE) {
                    return "";
                }
                
                DWORD bytesWritten;
                WriteFile(hPipe, command, (DWORD)strlen(command), &bytesWritten, NULL);
                
                char response[8192];
                DWORD bytesRead;
                std::string result;
                if (ReadFile(hPipe, response, sizeof(response) - 1, &bytesRead, NULL)) {
                    response[bytesRead] = '\0';
                    result = response;
                }
                
                CloseHandle(hPipe);
                return result;
            };
            
            auto getCrontabPath = [this]() -> std::string {
                return (fs::path(getLinuxdbPath()) / "crontab").string();
            };
            
            if (expandedTokens.size() < 2) {
                std::cout << "Usage: crontab [-l | -e | -r]\n";
                std::cout << "  -l    List crontab entries\n";
                std::cout << "  -e    Edit crontab in lino\n";
                std::cout << "  -r    Remove all entries\n";
                std::cout << "\nCrontab format: min hour day month weekday command\n";
                std::cout << "Special: @reboot @hourly @daily @weekly @monthly @yearly\n";
                std::cout << "\nExample:\n";
                std::cout << "  */5 * * * * ping google.com\n";
                std::cout << "  @daily C:\\backup\\daily.bat\n";
                std::cout << "  @reboot echo System started\n";
            } else {
                std::string arg = expandedTokens[1];
                std::string crontabPath = getCrontabPath();
                
                if (arg == "-l") {
                    // List crontab
                    std::ifstream file(crontabPath);
                    if (file) {
                        std::string line;
                        bool hasJobs = false;
                        while (std::getline(file, line)) {
                            // Skip comments but show for context
                            std::cout << line << "\n";
                            if (!line.empty() && line[0] != '#') {
                                hasJobs = true;
                            }
                        }
                        if (!hasJobs) {
                            std::cout << "\n(No active jobs)\n";
                        }
                    } else {
                        std::cout << "No crontab file. Use 'crontab -e' to create one.\n";
                    }
                    
                } else if (arg == "-e") {
                    // Edit crontab with lino
                    char exePath[MAX_PATH];
                    GetModuleFileNameA(NULL, exePath, MAX_PATH);
                    fs::path linoPath = fs::path(exePath).parent_path() / "lino.exe";
                    
                    // Make sure crontab exists
                    if (!fs::exists(crontabPath)) {
                        std::ofstream ofs(crontabPath);
                        ofs << "# Linuxify crontab - edit scheduled tasks\n";
                        ofs << "# Format: min hour day month weekday command\n";
                        ofs << "# Example: 0 12 * * * echo Hello World\n";
                    }
                    
                    if (fs::exists(linoPath)) {
                        std::string cmdLine = "\"" + linoPath.string() + "\" \"" + crontabPath + "\"";
                        STARTUPINFOA si = {sizeof(si)};
                        PROCESS_INFORMATION pi;
                        if (CreateProcessA(NULL, (LPSTR)cmdLine.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
                            WaitForSingleObject(pi.hProcess, INFINITE);
                            CloseHandle(pi.hProcess);
                            CloseHandle(pi.hThread);
                        }
                        
                        // Tell crond to reload
                        std::string response = sendToCrond("RELOAD");
                        if (response.empty()) {
                            std::cout << "Crontab saved. Note: crond is not running.\n";
                            std::cout << "Start it with: crond (or crond --install for auto-start)\n";
                        } else {
                            printSuccess("Crontab saved and reloaded.");
                        }
                    } else {
                        printError("lino not found. Edit manually: " + crontabPath);
                    }
                    
                } else if (arg == "-r") {
                    std::cout << "Remove all cron jobs? (y/n): ";
                    char c;
                    std::cin >> c;
                    std::cin.ignore(10000, '\n');
                    
                    if (c == 'y' || c == 'Y') {
                        std::ofstream file(crontabPath);
                        file << "# Linuxify Crontab - Empty\n";
                        sendToCrond("RELOAD");
                        printSuccess("All cron jobs removed.");
                    } else {
                        std::cout << "Cancelled.\n";
                    }
                    
                } else {
                    printError("Unknown option: " + arg);
                    std::cout << "Use: crontab -l | -e | -r\n";
                }
            }
        } else if (cmd == "uninstall") {
            cmdUninstall(expandedTokens);

        } else if (cmd == "exit" || cmd == "quit") {
            ctx.running = false;
        } else {
            char exePath[MAX_PATH];
            GetModuleFileNameA(NULL, exePath, MAX_PATH);
            fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
            
            std::vector<std::string> extensions = {".exe", ".cmd", ".bat", ""};
            bool foundInCmds = false;
            
            for (const auto& ext : extensions) {
                fs::path cmdPath = cmdsDir / (cmd + ext);
                if (fs::exists(cmdPath)) {
                    std::string cmdLine = "\"" + cmdPath.string() + "\"";
                    for (size_t i = 1; i < expandedTokens.size(); i++) {
                        cmdLine += " \"" + expandedTokens[i] + "\"";
                    }
                    
                    foundInCmds = true;
                    // Use ChildHandler for consistent console behavior
                    ctx.lastExitCode = ChildHandler::spawn(cmdLine, ctx.currentDir, true);
                    break;
                }
            }
                    

            
            if (!foundInCmds) {
                if (!g_registry.executeRegisteredCommand(cmd, expandedTokens, ctx.currentDir)) {
                    printError("Command not found: " + cmd + ". Type 'help' for available commands.");
                }
            }
        }

        } catch (const std::filesystem::filesystem_error& e) {
            // Handle file system errors
            std::string msg = e.what();
            if (msg.find("permission denied") != std::string::npos || 
                msg.find("Access is denied") != std::string::npos) {
                printError("Permission denied: " + e.path1().string());
            } else if (msg.find("no such file") != std::string::npos || 
                       msg.find("cannot find") != std::string::npos) {
                printError("No such file or directory: " + e.path1().string());
            } else if (msg.find("directory not empty") != std::string::npos) {
                printError("Directory not empty: " + e.path1().string() + " (use rm -r for recursive delete)");
            } else {
                printError("File system error: " + std::string(e.what()));
            }
            ctx.lastExitCode = 1;
        } catch (const std::invalid_argument& e) {
            printError("Invalid argument: " + std::string(e.what()));
            ctx.lastExitCode = 1;
        } catch (const std::out_of_range& e) {
            printError("Value out of range: " + std::string(e.what()));
            ctx.lastExitCode = 1;
        } catch (const std::runtime_error& e) {
            printError("Runtime error: " + std::string(e.what()));
            ctx.lastExitCode = 1;
        } catch (const std::exception& e) {
            printError("Error: " + std::string(e.what()));
            ctx.lastExitCode = 1;
        } catch (...) {
            printError("An unexpected error occurred.");
            ctx.lastExitCode = 1;
        }

        if (cmd != "clear" && ctx.running) {
            ShellIO::sout << ShellIO::endl;
        }
    }

    void runExecutable(const std::string& path, const std::vector<std::string>& args) {
        std::string fullPath = resolvePath(path);
        
        if (!fs::exists(fullPath)) {
            printError("Cannot find: " + path);
            return;
        }
        
        std::string cmdLine;
        
        // Check if it's a shell script (.sh file)
        std::string ext = fs::path(fullPath).extension().string();
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        
        if (ext == ".sh") {
            // Parse shebang to determine interpreter - REQUIRED
            std::string interpreterPath;
            std::string interpreterSpec;  // Could be registry name or absolute path
            bool hasShebang = false;
            
            std::ifstream scriptFile(fullPath);
            if (scriptFile) {
                std::string firstLine;
                std::getline(scriptFile, firstLine);
                scriptFile.close();
                
                // Check for shebang #!
                if (firstLine.size() > 2 && firstLine[0] == '#' && firstLine[1] == '!') {
                    hasShebang = true;
                    std::string shebang = firstLine.substr(2);
                    // Trim whitespace
                    shebang.erase(0, shebang.find_first_not_of(" \t\r\n"));
                    shebang.erase(shebang.find_last_not_of(" \t\r\n") + 1);
                    
                    // Get the interpreter spec (first word, rest are args)
                    size_t spacePos = shebang.find(' ');
                    interpreterSpec = (spacePos != std::string::npos) ? shebang.substr(0, spacePos) : shebang;
                }
            }
            
            // Shebang is required
            if (!hasShebang) {
                printError("Script missing shebang line: " + path);
                printError("Add a shebang: #!<interpreter> (registry name or absolute path)");
                printError("Example: #!lish  or  #!C:\\path\\to\\interpreter.exe");
                return;
            }
            
            if (interpreterSpec.empty()) {
                printError("Invalid shebang - no interpreter specified");
                return;
            }
            
            // Normalize interpreter name for comparison
            std::string interpreterName = interpreterSpec;
            // Remove .exe if present
            if (interpreterName.size() > 4 && interpreterName.substr(interpreterName.size() - 4) == ".exe") {
                interpreterName = interpreterName.substr(0, interpreterName.size() - 4);
            }
            // Get basename (remove path)
            size_t lastSlash = interpreterName.find_last_of("/\\");
            if (lastSlash != std::string::npos) {
                interpreterName = interpreterName.substr(lastSlash + 1);
            }
            // Convert to lowercase for comparison
            std::transform(interpreterName.begin(), interpreterName.end(), interpreterName.begin(), ::tolower);
            
            // Check for internal interpreters (default, lish, bash, sh)
            // These should be handled by the internal interpreter, not looked up externally
            if (interpreterName == "default" || interpreterName == "lish" || 
                interpreterName == "bash" || interpreterName == "sh") {
                // Use the internal interpreter directly - run the script!
                // Pass args (excluding script name) to the script
                std::vector<std::string> scriptArgs;
                for (size_t i = 1; i < args.size(); i++) {
                    scriptArgs.push_back(args[i]);
                }
                runScript(fullPath, scriptArgs);
                return;
            }
            
            // Check if it's an absolute path or a registry name
            fs::path specPath(interpreterSpec);
            if (specPath.is_absolute() && fs::exists(interpreterSpec)) {
                // Direct absolute path
                interpreterPath = interpreterSpec;
            } else {
                // Try to look up in registry
                std::string regPath = g_registry.getExecutablePath(interpreterSpec);
                if (!regPath.empty() && fs::exists(regPath)) {
                    interpreterPath = regPath;
                } else if (fs::exists(interpreterSpec)) {
                    // Relative path that exists
                    interpreterPath = fs::absolute(interpreterSpec).string();
                } else {
                    printError("Interpreter not found: " + interpreterSpec);
                    printError("Either add it to registry: registry add " + interpreterSpec + " <path>");
                    printError("Or use an absolute path in the shebang");
                    return;
                }
            }
            
            cmdLine = "\"" + interpreterPath + "\" \"" + fullPath + "\"";
            // Add any additional arguments after the script name
            for (size_t i = 1; i < args.size(); i++) {
                cmdLine += " \"" + args[i] + "\"";
            }
        } else {
            // Regular executable
            cmdLine = "\"" + fullPath + "\"";
            for (size_t i = 1; i < args.size(); i++) {
                cmdLine += " \"" + args[i] + "\"";
            }
        }
        
        ctx.lastExitCode = ChildHandler::spawn(cmdLine, ctx.currentDir, true);
    }

    void init() {
        // Init Shell API
        ShellAPI::setCommandHandler([this](const std::string& cmd) {
            return this->executeAndCapture(cmd);
        });
        ShellAPI::startServer();
        
        loadPersistentVars();

        ctx.interpreter.getExecutor().setFallbackHandler([this](const std::vector<std::string>& args) {
            this->executeCommand(args);
            return 0;
        });
    }

    void shutdown() {
        ShellAPI::stopServer();
    }



    // Check if a command is a built-in Linuxify command
    bool isBuiltinCommand(const std::string& cmd) {
        static std::vector<std::string> builtins = {
            "pwd", "cd", "type", "clear", "help", 
            "lino", "lin", "registry", "history", "echo", "env", 
            "printenv", "export", "which", "jobs", "fg", "bg",
            // Admin commands
            "sudo", "setup", "uninstall",
            // Scheduler commands
            "crontab"
        };
        for (const auto& builtin : builtins) {
            if (cmd == builtin) return true;
        }
        return false;
    }

    // Execute a command and write output to file (internal execution, no Windows shell)
    // stdoutFile: file for stdout (empty = discard or capture)
    // stderrFile: file for stderr (empty = discard, "STDOUT" = merge with stdout)
    // append: true = append mode, false = overwrite
    // Returns: captured stdout if stdoutFile is empty, otherwise empty string
    std::string executeToFile(const std::string& cmdStr, const std::string& stdoutFile, 
                              const std::string& stderrFile, bool append) {
        std::string capturedOutput;
        
        // Tokenize
        std::vector<std::string> tokens = tokenize(cmdStr);
        if (tokens.empty()) return "";
        
        std::string cmd = tokens[0];
        
        // For remaining internal commands, capture output internally
    if (isBuiltinCommand(cmd)) {
        std::ostringstream oss;
        std::streambuf* oldCout = std::cout.rdbuf();
        std::cout.rdbuf(oss.rdbuf());
        
        executeCommand(tokens);
        
        std::cout.rdbuf(oldCout);
        capturedOutput = oss.str();
        
        // Write to file if specified
        if (!stdoutFile.empty()) {
            std::ofstream file;
            if (append) {
                file.open(stdoutFile, std::ios::app);
            } else {
                file.open(stdoutFile, std::ios::out);
            }
            if (file) {
                file << capturedOutput;
            }
        }
        return capturedOutput;
    }
        
        // External command - find executable
        std::string execPath;
        
        if (cmd.find('/') != std::string::npos || cmd.find('\\') != std::string::npos) {
            std::string resolved = resolvePath(cmd);
            if (fs::exists(resolved)) {
                execPath = resolved;
            }
        }
        
        if (execPath.empty()) {
            std::string regPath = g_registry.getExecutablePath(cmd);
            if (!regPath.empty() && fs::exists(regPath)) {
                execPath = regPath;
            }
        }
        
        if (execPath.empty()) {
            char exePath[MAX_PATH];
            GetModuleFileNameA(NULL, exePath, MAX_PATH);
            fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
            
            std::vector<std::string> exts = {".exe", ".cmd", ".bat", ""};
            for (const auto& ext : exts) {
                fs::path tryPath = cmdsDir / (cmd + ext);
                if (fs::exists(tryPath)) {
                    execPath = tryPath.string();
                    break;
                }
            }
        }
        
        if (execPath.empty()) {
            return "Error: Command '" + cmd + "' not found in Linuxify.";
        }
        
        // Build command line
        std::string cmdLine = "\"" + execPath + "\"";
        for (size_t i = 1; i < tokens.size(); i++) {
            cmdLine += " \"" + tokens[i] + "\"";
        }
        
        // Setup handles
        SECURITY_ATTRIBUTES saAttr;
        saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
        saAttr.bInheritHandle = TRUE;
        saAttr.lpSecurityDescriptor = NULL;
        
        HANDLE hStdoutRead = NULL, hStdoutWrite = NULL;
        HANDLE hStderrWrite = NULL;
        HANDLE hStdoutFile = INVALID_HANDLE_VALUE;
        HANDLE hStderrFile = INVALID_HANDLE_VALUE;
        
        // Setup stdout
        if (stdoutFile.empty()) {
            // Capture stdout via pipe
            CreatePipe(&hStdoutRead, &hStdoutWrite, &saAttr, 0);
            SetHandleInformation(hStdoutRead, HANDLE_FLAG_INHERIT, 0);
        } else {
            // Redirect stdout to file
            DWORD createDisp = append ? OPEN_ALWAYS : CREATE_ALWAYS;
            hStdoutFile = CreateFileA(stdoutFile.c_str(), GENERIC_WRITE, FILE_SHARE_READ,
                                      &saAttr, createDisp, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hStdoutFile != INVALID_HANDLE_VALUE && append) {
                SetFilePointer(hStdoutFile, 0, NULL, FILE_END);
            }
            hStdoutWrite = hStdoutFile;
        }
        
        // Setup stderr
        if (stderrFile == "STDOUT") {
            // Merge stderr with stdout
            hStderrWrite = hStdoutWrite;
        } else if (!stderrFile.empty()) {
            // Redirect stderr to separate file
            DWORD createDisp = append ? OPEN_ALWAYS : CREATE_ALWAYS;
            hStderrFile = CreateFileA(stderrFile.c_str(), GENERIC_WRITE, FILE_SHARE_READ,
                                      &saAttr, createDisp, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hStderrFile != INVALID_HANDLE_VALUE && append) {
                SetFilePointer(hStderrFile, 0, NULL, FILE_END);
            }
            hStderrWrite = hStderrFile;
        } else {
            // Discard stderr (redirect to NUL)
            hStderrWrite = CreateFileA("NUL", GENERIC_WRITE, 0, &saAttr, OPEN_EXISTING, 0, NULL);
        }
        
        STARTUPINFOA si;
        PROCESS_INFORMATION pi;
        ZeroMemory(&si, sizeof(si));
        si.cb = sizeof(si);
        si.hStdOutput = hStdoutWrite;
        si.hStdError = hStderrWrite;
        si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
        si.dwFlags |= STARTF_USESTDHANDLES;
        ZeroMemory(&pi, sizeof(pi));
        
        char cmdBuffer[8192];
        strncpy_s(cmdBuffer, cmdLine.c_str(), sizeof(cmdBuffer) - 1);
        
        if (CreateProcessA(NULL, cmdBuffer, NULL, NULL, TRUE, 0, NULL,
                           ctx.currentDir.c_str(), &si, &pi)) {
            // Close write handles so reading can detect EOF
            if (hStdoutFile != INVALID_HANDLE_VALUE) {
                // Don't close yet, process is using it
            } else if (hStdoutWrite) {
                CloseHandle(hStdoutWrite);
                hStdoutWrite = NULL;
            }
            
            // Read captured output if using pipe
            if (hStdoutRead) {
                char buffer[4096];
                DWORD bytesRead;
                while (ReadFile(hStdoutRead, buffer, sizeof(buffer) - 1, &bytesRead, NULL) && bytesRead > 0) {
                    buffer[bytesRead] = '\0';
                    capturedOutput += buffer;
                }
            }
            
            WaitForSingleObject(pi.hProcess, INFINITE);
            CloseHandle(pi.hProcess);
            CloseHandle(pi.hThread);
        }
        
        // Cleanup handles
        if (hStdoutRead) CloseHandle(hStdoutRead);
        if (hStdoutFile != INVALID_HANDLE_VALUE) CloseHandle(hStdoutFile);
        if (hStderrFile != INVALID_HANDLE_VALUE) CloseHandle(hStderrFile);
        if (hStderrWrite && hStderrWrite != hStdoutWrite && stderrFile.empty()) CloseHandle(hStderrWrite);
        
        return capturedOutput;
    }

    // Execute a command and capture its output (internal execution)
    std::string executeAndCapture(const std::string& cmdStr) {
        std::string output;
        
        // 0. Check for arithmetic expression
        if (Arith::isArithmeticExpression(cmdStr)) {
            try {
                return Arith::evaluate(cmdStr);
            } catch (...) {
                // Formatting error, fall through to treat as command
            }
        }
        
        // Tokenize to get the command name
        std::vector<std::string> tokens = tokenize(cmdStr);
        if (tokens.empty()) return "";
        
        std::string cmd = tokens[0];
        
        // Check if it's a built-in command
        if (isBuiltinCommand(cmd)) {
            // Capture stdout for built-in commands
            std::ostringstream capturedOutput;
            std::streambuf* oldCout = std::cout.rdbuf();
            std::cout.rdbuf(capturedOutput.rdbuf());
            
            // Execute the built-in command
            executeCommand(tokens);
            
            // Restore stdout
            std::cout.rdbuf(oldCout);
            output = capturedOutput.str();
        } else {
            // External command - check registry and cmds folder, use CreateProcess
            std::string execPath;
            
            // 1. Check if it's a path (starts with ./ or / or contains \)
            if (cmd.find('/') != std::string::npos || cmd.find('\\') != std::string::npos) {
                std::string resolved = resolvePath(cmd);
                if (fs::exists(resolved)) {
                    execPath = resolved;
                }
            }
            
            // 2. Check registry
            if (execPath.empty()) {
                std::string regPath = g_registry.getExecutablePath(cmd);
                if (!regPath.empty() && fs::exists(regPath)) {
                    execPath = regPath;
                }
            }
            
            // 3. Check cmds folder
            if (execPath.empty()) {
                char exePath[MAX_PATH];
                GetModuleFileNameA(NULL, exePath, MAX_PATH);
                fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
                
                std::vector<std::string> exts = {".exe", ".cmd", ".bat", ""};
                for (const auto& ext : exts) {
                    fs::path tryPath = cmdsDir / (cmd + ext);
                    if (fs::exists(tryPath)) {
                        execPath = tryPath.string();
                        break;
                    }
                }
            }
            
            if (!execPath.empty()) {
                // Build command line
                std::string cmdLine = "\"" + execPath + "\"";
                for (size_t i = 1; i < tokens.size(); i++) {
                    cmdLine += " \"" + tokens[i] + "\"";
                }
                
                // Create pipes for stdout capture
                SECURITY_ATTRIBUTES saAttr;
                saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
                saAttr.bInheritHandle = TRUE;
                saAttr.lpSecurityDescriptor = NULL;
                
                HANDLE hReadPipe, hWritePipe;
                if (CreatePipe(&hReadPipe, &hWritePipe, &saAttr, 0)) {
                    SetHandleInformation(hReadPipe, HANDLE_FLAG_INHERIT, 0);
                    
                    STARTUPINFOA si;
                    PROCESS_INFORMATION pi;
                    ZeroMemory(&si, sizeof(si));
                    si.cb = sizeof(si);
                    si.hStdOutput = hWritePipe;
                    si.hStdError = hWritePipe;
                    si.dwFlags |= STARTF_USESTDHANDLES;
                    ZeroMemory(&pi, sizeof(pi));
                    
                    char cmdBuffer[8192];
                    strncpy_s(cmdBuffer, cmdLine.c_str(), sizeof(cmdBuffer) - 1);
                    
                    if (CreateProcessA(NULL, cmdBuffer, NULL, NULL, TRUE, 0, NULL, 
                                       ctx.currentDir.c_str(), &si, &pi)) {
                        CloseHandle(hWritePipe);
                        
                        // Read output
                        char buffer[4096];
                        DWORD bytesRead;
                        while (ReadFile(hReadPipe, buffer, sizeof(buffer) - 1, &bytesRead, NULL) && bytesRead > 0) {
                            buffer[bytesRead] = '\0';
                            output += buffer;
                        }
                        
                        WaitForSingleObject(pi.hProcess, INFINITE);
                        CloseHandle(pi.hProcess);
                        CloseHandle(pi.hThread);
                    } else {
                        CloseHandle(hWritePipe);
                        output = "Error: Failed to create process for " + cmd;
                    }
                    CloseHandle(hReadPipe);
                }
            } else {
                // Command not found - NO delegation to Windows shell
                output = "Error: Command '" + cmd + "' not found in Linuxify.";
            }
        }
        
        return output;
    }

    size_t findSinglePipe(const std::string& str, size_t start = 0) {
        bool inQuote = false;
        char quoteChar = 0;
        for (size_t i = start; i < str.length(); i++) {
            if (inQuote) {
                if (str[i] == quoteChar) {
                    inQuote = false;
                }
            } else {
                if (str[i] == '"' || str[i] == '\'') {
                    inQuote = true;
                    quoteChar = str[i];
                } else if (str[i] == '|') {
                    if (i + 1 < str.length() && str[i + 1] == '|') {
                        i++;
                        continue;
                    }
                    if (i > 0 && str[i - 1] == '|') {
                        continue;
                    }
                    return i;
                }
            }
        }
        return std::string::npos;
    }

    std::string readHeredoc(const std::string& delimiter) {
        std::string content;
        std::string line;
        
        while (true) {
            std::cout << "> ";
            if (!std::getline(std::cin, line)) break;
            
            std::string trimmed = line;
            trimmed.erase(0, trimmed.find_first_not_of(" \t"));
            if (!trimmed.empty()) trimmed.erase(trimmed.find_last_not_of(" \t") + 1);
            
            if (trimmed == delimiter) break;
            
            content += line + "\n";
        }
        return content;
    }

    int executeWithStdin(const std::string& cmdPart, const std::string& stdinContent) {
        // Tokenize the command
        std::vector<std::string> tokens = tokenize(cmdPart);
        if (tokens.empty()) return 1;
        
        std::string cmd = tokens[0];
        
        // For remaining built-in commands, use internal handling with stdin
    if (isBuiltinCommand(cmd)) {
        std::ostringstream capturedOutput;
        std::streambuf* oldCout = std::cout.rdbuf();
        std::cout.rdbuf(capturedOutput.rdbuf());
        
        executeCommand(tokens);
        
        std::cout.rdbuf(oldCout);
        std::cout << capturedOutput.str();
        return 0;
    }
        
        // External command - find executable
        std::string execPath;
        
        if (cmd.find('/') != std::string::npos || cmd.find('\\') != std::string::npos) {
            std::string resolved = resolvePath(cmd);
            if (fs::exists(resolved)) {
                execPath = resolved;
            }
        }
        
        if (execPath.empty()) {
            std::string regPath = g_registry.getExecutablePath(cmd);
            if (!regPath.empty() && fs::exists(regPath)) {
                execPath = regPath;
            }
        }
        
        if (execPath.empty()) {
            char exePath[MAX_PATH];
            GetModuleFileNameA(NULL, exePath, MAX_PATH);
            fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
            
            std::vector<std::string> exts = {".exe", ".cmd", ".bat", ""};
            for (const auto& ext : exts) {
                fs::path tryPath = cmdsDir / (cmd + ext);
                if (fs::exists(tryPath)) {
                    execPath = tryPath.string();
                    break;
                }
            }
        }
        
        if (execPath.empty()) {
            printError("Command '" + cmd + "' not found in Linuxify.");
            return 1;
        }
        
        // Write stdin content to temp file
        char tempPath[MAX_PATH];
        char tempFile[MAX_PATH];
        GetTempPathA(MAX_PATH, tempPath);
        GetTempFileNameA(tempPath, "lin", 0, tempFile);
        
        std::ofstream tf(tempFile);
        tf << stdinContent;
        tf.close();
        
        // Build command line
        std::string cmdLine = "\"" + execPath + "\"";
        for (size_t i = 1; i < tokens.size(); i++) {
            cmdLine += " \"" + tokens[i] + "\"";
        }
        
        // Setup handles for stdin from file
        SECURITY_ATTRIBUTES saAttr;
        saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
        saAttr.bInheritHandle = TRUE;
        saAttr.lpSecurityDescriptor = NULL;
        
        HANDLE hStdinFile = CreateFileA(tempFile, GENERIC_READ, FILE_SHARE_READ,
                                         &saAttr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        
        STARTUPINFOA si;
        PROCESS_INFORMATION pi;
        ZeroMemory(&si, sizeof(si));
        si.cb = sizeof(si);
        si.dwFlags = STARTF_USESTDHANDLES;
        si.hStdInput = hStdinFile;
        si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
        si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
        ZeroMemory(&pi, sizeof(pi));
        
        char cmdBuffer[8192];
        strncpy_s(cmdBuffer, cmdLine.c_str(), sizeof(cmdBuffer) - 1);
        
        int exitCode = 0;
        if (CreateProcessA(NULL, cmdBuffer, NULL, NULL, TRUE, 0, NULL, 
                           ctx.currentDir.c_str(), &si, &pi)) {
            WaitForSingleObject(pi.hProcess, INFINITE);
            DWORD code;
            GetExitCodeProcess(pi.hProcess, &code);
            exitCode = (int)code;
            CloseHandle(pi.hProcess);
            CloseHandle(pi.hThread);
        } else {
            exitCode = 1;
        }
        
        CloseHandle(hStdinFile);
        DeleteFileA(tempFile);
        return exitCode;
    }

    bool handleRedirection(const std::string& input) {
        // Check for stderr redirections first
        size_t stderrToStdout = input.find("2>&1");
        size_t stderrAppend = input.find("2>>");
        size_t stderrWrite = input.find("2>");
        size_t bothAppend = input.find("&>>");
        size_t bothWrite = input.find("&>");
        
        // Handle 2>&1 - redirect stderr to stdout (strip it and let external command handle it)
        std::string processedInput = input;
        bool mergeStderr = false;
        
        if (stderrToStdout != std::string::npos) {
            // Remove 2>&1 from input and set flag
            processedInput = input.substr(0, stderrToStdout);
            if (stderrToStdout + 4 < input.length()) {
                processedInput += input.substr(stderrToStdout + 4);
            }
            // Trim
            processedInput.erase(processedInput.find_last_not_of(" \t") + 1);
            mergeStderr = true;
        }
        
        // Handle &> or &>> (redirect both stdout and stderr to file)
        if (bothWrite != std::string::npos || bothAppend != std::string::npos) {
            bool append = (bothAppend != std::string::npos && (bothWrite == std::string::npos || bothAppend < bothWrite));
            size_t pos = append ? bothAppend : bothWrite;
            size_t skip = append ? 3 : 2;
            
            std::string cmdPart = input.substr(0, pos);
            std::string filePart = input.substr(pos + skip);
            
            cmdPart.erase(cmdPart.find_last_not_of(" \t") + 1);
            filePart.erase(0, filePart.find_first_not_of(" \t"));
            filePart.erase(filePart.find_last_not_of(" \t") + 1);
            
            if (filePart.empty()) {
                printError("Syntax error: missing filename after redirect");
                return true;
            }
            
            std::string outputFile = resolvePath(filePart);
            
            // Execute with stderr merged using internal execution
            std::vector<std::string> tokens = tokenize(cmdPart);
            if (tokens.empty()) return true;
            
            // Use executeToFile with stdout to file, stderr merged to stdout
            executeToFile(cmdPart, outputFile, "STDOUT", append);
            
            return true;
        }
        
        // Handle 2> or 2>> (redirect only stderr to file) - but NOT if 2>&1 was detected
        if (stderrToStdout == std::string::npos && 
            ((stderrWrite != std::string::npos && stderrWrite != stderrAppend - 1) || stderrAppend != std::string::npos)) {
            bool append = (stderrAppend != std::string::npos);
            size_t pos = append ? stderrAppend : stderrWrite;
            size_t skip = append ? 3 : 2;
            
            std::string cmdPart = input.substr(0, pos);
            std::string filePart = input.substr(pos + skip);
            
            cmdPart.erase(cmdPart.find_last_not_of(" \t") + 1);
            filePart.erase(0, filePart.find_first_not_of(" \t"));
            filePart.erase(filePart.find_last_not_of(" \t") + 1);
            
            if (filePart.empty()) {
                printError("Syntax error: missing filename after redirect");
                return true;
            }
            
            std::string stderrFile = resolvePath(filePart);
            
            // Execute command with stderr redirected to file using internal execution
            executeToFile(cmdPart, "", stderrFile, append);
            
            return true;
        }
        
        size_t hereStringPos = processedInput.find("<<<");
        size_t heredocPos = processedInput.find("<<");
        size_t inputRedirPos = processedInput.find("<");
        
        if (heredocPos != std::string::npos && heredocPos == hereStringPos) {
            heredocPos = std::string::npos;
        }
        if (inputRedirPos != std::string::npos && (inputRedirPos == heredocPos || inputRedirPos == hereStringPos || inputRedirPos + 1 == heredocPos)) {
            inputRedirPos = std::string::npos;
        }
        
        if (hereStringPos != std::string::npos) {
            std::string cmdPart = processedInput.substr(0, hereStringPos);
            std::string stringPart = processedInput.substr(hereStringPos + 3);
            
            cmdPart.erase(cmdPart.find_last_not_of(" \t") + 1);
            stringPart.erase(0, stringPart.find_first_not_of(" \t"));
            
            if (stringPart.front() == '"' || stringPart.front() == '\'') {
                char quote = stringPart.front();
                stringPart = stringPart.substr(1);
                size_t endQuote = stringPart.find(quote);
                if (endQuote != std::string::npos) {
                    stringPart = stringPart.substr(0, endQuote);
                }
            } else {
                size_t endSpace = stringPart.find_first_of(" \t");
                if (endSpace != std::string::npos) {
                    stringPart = stringPart.substr(0, endSpace);
                }
            }
            
            std::vector<std::string> tokens = tokenize(cmdPart);
            if (!tokens.empty()) {
                std::string& cmd = tokens[0];
                std::istringstream iss(stringPart);
                
                std::ostringstream capturedOutput;
                std::streambuf* oldCout = std::cout.rdbuf();
                std::cout.rdbuf(capturedOutput.rdbuf());
                if (isBuiltinCommand(cmd)) {
                    executeCommand(tokens);
                } else {
                    std::cout.rdbuf(oldCout);
                    ctx.lastExitCode = executeWithStdin(cmdPart, stringPart + "\n");
                    return true;
                }
                
                std::cout.rdbuf(oldCout);
                std::cout << capturedOutput.str();
            }
            return true;
        }
        
        if (heredocPos != std::string::npos && (hereStringPos == std::string::npos || heredocPos < hereStringPos)) {
            std::string cmdPart = processedInput.substr(0, heredocPos);
            std::string delimPart = processedInput.substr(heredocPos + 2);
            
            cmdPart.erase(cmdPart.find_last_not_of(" \t") + 1);
            delimPart.erase(0, delimPart.find_first_not_of(" \t"));
            delimPart.erase(delimPart.find_last_not_of(" \t\r\n") + 1);
            
            if (delimPart.empty()) {
                printError("Syntax error: missing delimiter after <<");
                return true;
            }
            
            std::string heredocContent = readHeredoc(delimPart);
            
            std::vector<std::string> tokens = tokenize(cmdPart);
            if (!tokens.empty()) {
                std::string& cmd = tokens[0];
                if (isBuiltinCommand(cmd)) {
                    executeCommand(tokens);
                } else {
                    ctx.lastExitCode = executeWithStdin(cmdPart, heredocContent);
                }
            }
            return true;
        }
        
        if (inputRedirPos != std::string::npos && inputRedirPos > 0) {
            bool isStderrRedir = (inputRedirPos > 0 && processedInput[inputRedirPos - 1] == '2');
            bool isAmpRedir = (inputRedirPos > 0 && processedInput[inputRedirPos - 1] == '&');
            
            if (!isStderrRedir && !isAmpRedir) {
                std::string cmdPart = processedInput.substr(0, inputRedirPos);
                std::string filePart = processedInput.substr(inputRedirPos + 1);
                
                cmdPart.erase(cmdPart.find_last_not_of(" \t") + 1);
                filePart.erase(0, filePart.find_first_not_of(" \t"));
                filePart.erase(filePart.find_last_not_of(" \t") + 1);
                
                if (filePart.empty()) {
                    printError("Syntax error: missing filename after <");
                    return true;
                }
                
                std::string inputFile = resolvePath(filePart);
                if (!fs::exists(inputFile)) {
                    printError("No such file: " + filePart);
                    ctx.lastExitCode = 1;
                    return true;
                }
                
                std::ifstream ifs(inputFile);
                std::string fileContent((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
                ifs.close();
                
                std::vector<std::string> tokens = tokenize(cmdPart);
                if (!tokens.empty()) {
                    std::string& cmd = tokens[0];
                    
                    if (cmd == "grep") cmdGrep(tokens, fileContent);
                    else if (cmd == "wc") cmdWc(tokens, fileContent);
                    else if (cmd == "cat") {
                        std::cout << fileContent;
                    }
                    else {
                        ctx.lastExitCode = executeWithStdin(cmdPart, fileContent);
                    }
                }
                return true;
            }
        }
        
        size_t appendPos = processedInput.find(">>");
        size_t writePos = processedInput.find(">");
        size_t pipePos = findSinglePipe(processedInput);
        
        // Handle PIPE + REDIRECTION together (e.g., ls | grep ".txt" > log.txt)
        // Check if we have both a pipe AND output redirection
        if (pipePos != std::string::npos && 
            (appendPos != std::string::npos || writePos != std::string::npos)) {
            
            // Find the last pipe position
            size_t lastPipePos = pipePos;
            size_t tempPos = pipePos;
            while ((tempPos = findSinglePipe(processedInput, tempPos + 1)) != std::string::npos) {
                lastPipePos = tempPos;
            }
            
            // Determine redirect position (prefer >> over > if >> comes first)
            bool append = (appendPos != std::string::npos && 
                          (writePos == std::string::npos || appendPos < writePos));
            size_t redirectPos = append ? appendPos : writePos;
            
            // Only handle here if redirection comes AFTER the last pipe
            if (redirectPos != std::string::npos && redirectPos > lastPipePos) {
                size_t skip = append ? 2 : 1;
                
                // Extract pipeline (before >) and output file (after >)
                std::string pipelinePart = processedInput.substr(0, redirectPos);
                std::string filePart = processedInput.substr(redirectPos + skip);
                
                // Trim
                pipelinePart.erase(pipelinePart.find_last_not_of(" \t") + 1);
                filePart.erase(0, filePart.find_first_not_of(" \t"));
                filePart.erase(filePart.find_last_not_of(" \t") + 1);
                
                if (filePart.empty()) {
                    printError("Syntax error: missing filename after redirect");
                    return true;
                }
                
                std::string outputFile = resolvePath(filePart);
                
                // Execute the pipeline and capture output
                std::vector<std::string> commands;
                std::string remaining = pipelinePart;
                size_t pPos;
                
                while ((pPos = findSinglePipe(remaining)) != std::string::npos) {
                    std::string cmd = remaining.substr(0, pPos);
                    cmd.erase(0, cmd.find_first_not_of(" \t"));
                    cmd.erase(cmd.find_last_not_of(" \t") + 1);
                    commands.push_back(cmd);
                    remaining = remaining.substr(pPos + 1);
                }
                remaining.erase(0, remaining.find_first_not_of(" \t"));
                remaining.erase(remaining.find_last_not_of(" \t") + 1);
                commands.push_back(remaining);
                
                // Open file handle
                SECURITY_ATTRIBUTES sa;
                sa.nLength = sizeof(SECURITY_ATTRIBUTES);
                sa.bInheritHandle = TRUE;
                sa.lpSecurityDescriptor = NULL;

                HANDLE hFile = CreateFileA(outputFile.c_str(), GENERIC_WRITE, FILE_SHARE_READ, &sa,
                                           append ? OPEN_ALWAYS : CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
                if (hFile == INVALID_HANDLE_VALUE) {
                     printError("Cannot open output file: " + outputFile);
                     return true;
                }
                if (append) SetFilePointer(hFile, 0, NULL, FILE_END);
                
                // Execute using native pipeline
                ctx.lastExitCode = executePipeline(commands, hFile);
                CloseHandle(hFile);
                
                return true;
            }
        }
        
        if (appendPos != std::string::npos || writePos != std::string::npos) {
            bool append = (appendPos != std::string::npos && (writePos == std::string::npos || appendPos <= writePos));
            size_t pos = append ? appendPos : writePos;
            size_t skip = append ? 2 : 1;
            
            std::string cmdPart = processedInput.substr(0, pos);
            std::string filePart = processedInput.substr(pos + skip);
            
            cmdPart.erase(cmdPart.find_last_not_of(" \t") + 1);
            filePart.erase(0, filePart.find_first_not_of(" \t"));
            filePart.erase(filePart.find_last_not_of(" \t") + 1);
            
            if (filePart.empty()) {
                printError("Syntax error: missing filename after redirect");
                return true;
            }
            
            std::string outputFile = resolvePath(filePart);
            
            std::vector<std::string> commands;
            size_t pPos = 0;
            std::string tempCmd = cmdPart;
            while ((pPos = findSinglePipe(tempCmd)) != std::string::npos) {
                 std::string c = tempCmd.substr(0, pPos);
                 c.erase(0, c.find_first_not_of(" \t"));
                 c.erase(c.find_last_not_of(" \t") + 1);
                 commands.push_back(c);
                 tempCmd = tempCmd.substr(pPos + 1);
            }
            tempCmd.erase(0, tempCmd.find_first_not_of(" \t"));
            tempCmd.erase(tempCmd.find_last_not_of(" \t") + 1);
            commands.push_back(tempCmd);
            
            SECURITY_ATTRIBUTES sa;
            sa.nLength = sizeof(SECURITY_ATTRIBUTES);
            sa.bInheritHandle = TRUE;
            sa.lpSecurityDescriptor = NULL;

            HANDLE hFile = CreateFileA(outputFile.c_str(), GENERIC_WRITE, FILE_SHARE_READ, &sa,
                                       append ? OPEN_ALWAYS : CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hFile == INVALID_HANDLE_VALUE) {
                 printError("Cannot open output file: " + outputFile);
                 return true;
            }
            if (append) SetFilePointer(hFile, 0, NULL, FILE_END);
            
            ctx.lastExitCode = executePipeline(commands, hFile);
            CloseHandle(hFile);
            return true;
        }
        return false;
    }

    int executeCommandLine(const std::string& cmdLine) {
        // Expand variables first
        std::string expanded = expandVariables(cmdLine);
        
        std::string trimmed = expanded;
        trimmed.erase(0, trimmed.find_first_not_of(" \t"));
        if (!trimmed.empty()) trimmed.erase(trimmed.find_last_not_of(" \t") + 1);
        
        bool runInBackground = false;
        if (!trimmed.empty() && trimmed.back() == '&') {
            runInBackground = true;
            trimmed.pop_back(); // Remove the '&'
            trimmed.erase(trimmed.find_last_not_of(" \t") + 1); // Trim any spaces before '&'
        }

        // Explicit AutoNav: if inputs start with markers (./, /, ~, ..)
        if (AutoNav::isNavigablePath(trimmed, ctx.currentDir)) {
            std::string targetDir = AutoNav::getResolvedDirectory(trimmed, ctx.currentDir);
            try {
                if (fs::exists(targetDir) && fs::is_directory(targetDir)) {
                    ctx.currentDir = fs::canonical(targetDir).string();
                    return 0;
                }
            } catch (...) {}
        }

        if (handleRedirection(trimmed)) {
            return ctx.lastExitCode;
        }

        // Check for pure pipeline (or pipeline with implied stdout)
        if (findSinglePipe(trimmed) != std::string::npos) {
             std::vector<std::string> commands;
             size_t pPos = 0;
             std::string tempCmd = trimmed;
             while ((pPos = findSinglePipe(tempCmd)) != std::string::npos) {
                  std::string c = tempCmd.substr(0, pPos);
                  c.erase(0, c.find_first_not_of(" \t"));
                  if (!c.empty()) c.erase(c.find_last_not_of(" \t") + 1);
                  commands.push_back(c);
                  tempCmd = tempCmd.substr(pPos + 1);
             }
             tempCmd.erase(0, tempCmd.find_first_not_of(" \t"));
             if (!tempCmd.empty()) tempCmd.erase(tempCmd.find_last_not_of(" \t") + 1);
             commands.push_back(tempCmd);
             
             ctx.lastExitCode = executePipeline(commands);
             return ctx.lastExitCode;
        }

        std::vector<std::string> tokens = tokenize(trimmed);
        if (tokens.empty()) return 0;
        
        std::string cmd = tokens[0];
        
        // Implicit AutoNav logic: Check if command exists
        bool isCommand = false;
        if (internalCmds.count(cmd)) isCommand = true;
        else if (!g_registry.getExecutablePath(cmd).empty()) isCommand = true;
        // Note via PATH search is hard to check perfectly without attempting execution, 
        // but we prioritize local dir if not internal/registry.
        
        if (!isCommand) {
            // Check if it is a directory
            if (fs::exists(trimmed) && fs::is_directory(trimmed)) {
                try {
                    ctx.currentDir = fs::canonical(trimmed).string();
                    return 0;
                } catch(...) {}
            }
            // Check if it is a file
            else if (fs::exists(trimmed) && !fs::is_directory(trimmed)) {
                std::string ext = fs::path(trimmed).extension().string();
                std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
                if (ext != ".exe" && ext != ".bat" && ext != ".cmd" && ext != ".ps1" && ext != ".com") {
                    printError(trimmed + ": Is a file");
                    return 1;
                }
            }
        }

        // Re-tokenize after potential AutoNav handling if it wasn't a directory change
        tokens = tokenize(trimmed);
        if (tokens.empty()) return 0;

        cmd = tokens[0];

        if (cmd.substr(0, 2) == "./" || cmd.substr(0, 2) == ".\\" ||
            cmd.find('/') != std::string::npos || cmd.find('\\') != std::string::npos ||
            (cmd.length() > 4 && cmd.substr(cmd.length() - 4) == ".exe")) {
            std::string resolvedCmd = resolvePath(cmd);
            if (fs::exists(resolvedCmd) && fs::is_directory(resolvedCmd)) {
                try {
                    ctx.currentDir = fs::canonical(resolvedCmd).string();
                    return 0;
                } catch (...) {}
            }
            std::string execPath = cmd;
            if (cmd.substr(0, 2) == "./" || cmd.substr(0, 2) == ".\\") {
                execPath = cmd.substr(2);
            }
            
            if (runInBackground) {
                // To run in the background we need to call ChildHandler::spawn but NOT wait.
                // However, runExecutable inside might be hardcoded to wait, let's just launch directly:
                std::string fullCmdArgs = "\"" + resolvePath(execPath) + "\"";
                for (size_t i = 1; i < tokens.size(); i++) {
                    fullCmdArgs += " \"" + tokens[i] + "\"";
                }
                
                // Spawn the process and DO NOT wait
                ChildHandler::spawn(fullCmdArgs, ctx.currentDir, false);
                return 0; // Immediate return for background processes
            } else {
                runExecutable(execPath, tokens);
            }
        } else {
            if (runInBackground && !internalCmds.count(cmd)) {
                // Find executable
                std::string execPath;
                std::string regPath = g_registry.getExecutablePath(cmd);
                if (!regPath.empty() && fs::exists(regPath)) execPath = regPath;
                else {
                    char exePath[MAX_PATH];
                    GetModuleFileNameA(NULL, exePath, MAX_PATH);
                    fs::path cmdsDir = fs::path(exePath).parent_path() / "cmds";
                    std::vector<std::string> exts = {".exe", ".cmd", ".bat", ""};
                    for (const auto& ext : exts) {
                        fs::path tryPath = cmdsDir / (cmd + ext);
                        if (fs::exists(tryPath)) { execPath = tryPath.string(); break; }
                    }
                }
                if (execPath.empty()) execPath = cmd;
                
                std::string fullCmdArgs = "\"" + execPath + "\"";
                for (size_t i = 1; i < tokens.size(); i++) {
                    fullCmdArgs += " \"" + tokens[i] + "\"";
                }
                ChildHandler::spawn(fullCmdArgs, ctx.currentDir, false);
                return 0;
            } else {
                executeCommand(tokens);
            }
        }
        return ctx.lastExitCode;
    }

    std::string expandHistoryInString(const std::string& input) {
        std::string result = input;
        size_t pos = 0;
        while ((pos = result.find("!!", pos)) != std::string::npos) {
            if (!ctx.commandHistory.empty()) {
                result.replace(pos, 2, ctx.commandHistory.back());
                pos += ctx.commandHistory.back().length();
            } else {
                pos += 2;
            }
        }
        return result;
    }

    bool handleChainedCommands(const std::string& input) {
        size_t orPos = input.find("||");
        size_t andPos = input.find("&&");
        
        if (orPos == std::string::npos && andPos == std::string::npos) {
            return false;
        }
        
        struct ChainPart {
            std::string cmd;
            int opType;
        };
        std::vector<ChainPart> parts;
        std::string remaining = input;
        
        while (true) {
            orPos = remaining.find("||");
            andPos = remaining.find("&&");
            
            size_t minPos = std::string::npos;
            int opType = 0;
            
            if (orPos != std::string::npos && (andPos == std::string::npos || orPos < andPos)) {
                minPos = orPos;
                opType = 1;
            } else if (andPos != std::string::npos) {
                minPos = andPos;
                opType = 2;
            }
            
            if (minPos == std::string::npos) {
                std::string cmd = remaining;
                cmd.erase(0, cmd.find_first_not_of(" \t"));
                if (!cmd.empty()) cmd.erase(cmd.find_last_not_of(" \t") + 1);
                parts.push_back({cmd, 0});
                break;
            }
            
            std::string cmd = remaining.substr(0, minPos);
            cmd.erase(0, cmd.find_first_not_of(" \t"));
            if (!cmd.empty()) cmd.erase(cmd.find_last_not_of(" \t") + 1);
            parts.push_back({cmd, opType});
            remaining = remaining.substr(minPos + 2);
        }
        
        if (parts.size() <= 1 && parts[0].opType == 0) {
            return false;
        }
        
        int exitCode = 0;
        for (size_t i = 0; i < parts.size(); i++) {
            if (i == 0) {
                exitCode = executeCommandLine(parts[i].cmd);
            } else {
                int prevOp = parts[i - 1].opType;
                if (prevOp == 1 && exitCode != 0) {
                    exitCode = executeCommandLine(parts[i].cmd);
                } else if (prevOp == 2 && exitCode == 0) {
                    exitCode = executeCommandLine(parts[i].cmd);
                } else if (prevOp == 1 && exitCode == 0) {
                } else if (prevOp == 2 && exitCode != 0) {
                }
            }
        }
        
        return true;
    }






    int runScript(const std::string& filename, const std::vector<std::string>& args = {}) {
        std::ifstream file(filename);
        if (!file) {
            printError("Script not found: " + filename);
            return 1;
        }
        
        // Skip shebang if present
        std::string line;
        std::getline(file, line);
        if (line.size() > 2 && line[0] == '#' && line[1] == '!') {
            // Check for recursive lish execution
            std::string shebang = line.substr(2);
            if (shebang.find("lish") != std::string::npos) {
                printError("No Goofy shebangs allowed ;), thats basically inception. Sooooo...... Yeah");
                return 1;
            }
        } else {
            // Not a shebang, rewind
            file.clear();
            file.seekg(0);
        }
        
        // Set up script arguments ($0, $1, $2, etc.)
        std::vector<std::string> scriptArgs;
        scriptArgs.push_back(filename);  // $0 is script name
        for (const auto& arg : args) {
            scriptArgs.push_back(arg);
        }
        ctx.interpreter.setScriptArgs(scriptArgs);
        
        std::stringstream buffer;
        buffer << file.rdbuf();
        int result = 0;
        try {
            result = ctx.interpreter.runCode(buffer.str());
        } catch (const Bash::ExitException& e) {
            result = e.code;
        }
        
        ctx.interpreter.clearScriptArgs();
        return result;
    }
    
    // Run a single command string (e.g. from -c)
    int runCommand(const std::string& command) {
        return ctx.interpreter.runCode(command);
    }
    
};




void execute_command_logic(ShellContext& ctx, const std::string& input) {
    if (input.empty()) return;

    ShellLogic logic(ctx);
    
    std::string expandedInput = logic.expandHistoryInString(input);
    
    // Resolve aliases early so they apply to everything (arithmetic, shell syntax, internal cmds)
    std::string resolvedInput = ctx.aliasInContext.resolve(expandedInput);
    
    std::string trimmed = resolvedInput;
    trimmed.erase(0, trimmed.find_first_not_of(" \t"));
    if (!trimmed.empty()) trimmed.erase(trimmed.find_last_not_of(" \t") + 1);
    
    if (!trimmed.empty()) {
        logic.saveToHistory(trimmed);
    }
    
    if (trimmed.empty()) return;

    // SAAO Parsing: ^<([^>]+)>:<([^>]+)>\[(.*)\]$
    std::regex saaoRegex("^<([^>]+)>:<([^>]+)>\\[(.*)\\]$");
    std::smatch match;
    if (std::regex_match(trimmed, match, saaoRegex)) {
        std::string targetSeshStr = match[1];
        std::string command = match[2];
        std::string rawArgs = match[3];

        int currentId = ctx.sessionId;
        std::string currentName = ctx.sessionName;
        
        int targetId = -1;
        try {
            targetId = std::stoi(targetSeshStr);
        } catch (...) {
            targetId = g_sessionManager.getSessionIdByName(targetSeshStr);
        }

        if (targetId != currentId && targetSeshStr != currentName) {
            std::cerr << "SAAO Error: Incorrect current session specified. You are in [" << currentName << " | " << currentId << "]\n";
            ctx.lastExitCode = 1;
            return;
        }

        if (command == "add") {
            std::string newName = "";
            if (rawArgs.length() >= 3 && rawArgs.substr(0, 3) == "-n ") {
                newName = rawArgs.substr(3);
                newName.erase(0, newName.find_first_not_of(" \t"));
                if (!newName.empty()) newName.erase(newName.find_last_not_of(" \t") + 1);
            }
            int newId = g_sessionManager.addSession(currentId, newName);
            // Awoke back
            if (newId != -1) {
                std::cout << "\n[SAAO: Resumed session " << currentName << "]\n";
            }
        } else if (command == "switch") {
            int switchTargetId = -1;
            try {
                switchTargetId = std::stoi(rawArgs);
            } catch (...) {
                switchTargetId = g_sessionManager.getSessionIdByName(rawArgs);
            }

            if (!g_sessionManager.hasSession(switchTargetId)) {
                std::cerr << "SAAO Error: Session '" << rawArgs << "' does not exist.\n";
            } else if (!g_sessionManager.canSwitchTo(currentId, switchTargetId)) {
                std::cerr << "SAAO Error: Cannot switch to '" << rawArgs << "'. It's not a parent or direct child.\n";
            } else {
                g_sessionManager.switchSession(switchTargetId);
                // Awoke back
                std::cout << "\n[SAAO: Resumed session " << currentName << "]\n";
            }
        } else if (command == "pop") {
            int popTargetId = -1;
            try {
                popTargetId = std::stoi(rawArgs);
            } catch (...) {
                popTargetId = g_sessionManager.getSessionIdByName(rawArgs);
            }

            if (!g_sessionManager.hasSession(popTargetId)) {
                std::cerr << "SAAO Error: Session '" << rawArgs << "' does not exist.\n";
            } else {
                if (g_sessionManager.deleteSession(popTargetId)) {
                    std::cout << "SAAO: Session '" << rawArgs << "' and its entire hierarchy have been deleted.\n";
                }
            }
        } else {
            std::cerr << "SAAO Error: Unknown subcommand '" << command << "'\n";
        }
        
        ctx.lastExitCode = 0;
        return;
    }

    if (Arith::isArithmeticExpression(trimmed)) {
        try {
            std::string result = Arith::evaluate(trimmed);
            std::cout << result << std::endl;
            ctx.lastExitCode = 0;
            return;
        } catch (...) {
        }
    }

    // Check for shell syntax first
    if (logic.isShellSyntax(trimmed)) {
        ctx.lastExitCode = ctx.interpreter.runCode(trimmed);
        return;
    }

    // Check if it's a known shell function
    // Simple extraction of first word to check against function list
    std::string firstWord = trimmed;
    size_t spacePos = trimmed.find_first_of(" \t\n;");
    if (spacePos != std::string::npos) firstWord = trimmed.substr(0, spacePos);
    
    if (ctx.interpreter.hasFunction(firstWord)) {
         ctx.lastExitCode = ctx.interpreter.runCode(trimmed);
         return;
    }

    // Handle chained commands (&&, ||)
    if (trimmed.find("&&") != std::string::npos || trimmed.find("||") != std::string::npos) {
        logic.handleChainedCommands(trimmed);
    } else {
        namespace fs = std::filesystem;
        fs::path resolvedPath = fs::path(ctx.currentDir) / trimmed;
        if (fs::exists(resolvedPath) && fs::is_directory(resolvedPath)) {
            try {
                ctx.currentDir = fs::canonical(resolvedPath).string();
                ctx.lastExitCode = 0;
                return;
            } catch (...) {}
        }
        logic.executeCommandLine(trimmed);
    }
}

// --- State Boot ---
class StateBoot : public Continuation {
public:
    std::string getName() const override { return "Boot"; }

    std::unique_ptr<Continuation> run(ShellContext& ctx) override {
        // We can access ShellLogic generic init methods if we expose them
        // For now, let's just do the visual init here or call a helper in ShellLogic
        ShellLogic logic(ctx);
        
        // Load History (was in run() before)
        logic.loadHistory(); 
        logic.loadPersistentVars(); 
        
        // Print Tux (was in run() before)
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        
        if (g_sessionManager.currentSessionId == 0) {
            IO::get().clearScreen();
            
            // Print Tux penguin with colors (yellow body, white eyes)
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "         .---.         ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "  _     _                  _  __\n";
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "        /     \\        ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << " | |   (_)_ __  _   ___  _(_)/ _|_   _\n";
            
            // Eyes line - split for white eyes
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "        \\.";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY); // White
            std::cout << "@-@";
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "./        ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << " | |   | | '_ \\| | | \\ \\/ / | |_| | | |\n";
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "        /`\\_/`\\        ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << " | |___| | | | | |_| |>  <| |  _| |_| |\n";
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "       //  _  \\\\       ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << " |_____|_|_| |_|\\__,_/_/\\_\\_|_|  \\__, |\n";
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "      | \\     )|_      ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            std::cout << "                                 |___/\n";
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow
            std::cout << "     /`\\_`>  <_/ \\     \n";
            std::cout << "     \\__/'---'\\__/     ";
            SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
            std::cout << "                             By Cortez\n" << std::endl;
            
            SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
            std::cout << "  Linux Commands for Windows - Type 'help' for commands\n";
            std::cout << "  Licensed under GPLv3 - Free Software Foundation\n" << std::endl;
        }

        logic.loadLinuxifyRC();

        // Note: Crond starting logic was also in run(). 
        // We can replicate it here or move it to a shared helper. 
        // For brevity implying it's handled or we add it later if needed.
        // Actually, let's just call into logic if possible or assume system handles it.
        // The original logic had a block for crond inside run().
        
        return std::make_unique<StatePrompt>();
    }
};

int main(int argc, char* argv[]) {
    // 1. Initialize Crash Handler immediately
    CrashHandler::init();
    srand((unsigned int)time(nullptr));
    
    // Enterprise System Initialization
    Interrupt::init();

    // SAAO Initialization
    bool isSaaoChild = false;
    if (argc >= 4 && std::string(argv[1]) == "--saao") {
        isSaaoChild = true;
        int mPid = std::stoi(argv[2]);
        int sId = std::stoi(argv[3]);
        g_sessionManager.initChild(mPid, sId);
    } else {
        g_sessionManager.initMaster();
    }
    
        //for /c suport
    if (argc >= 2) {
        std::string arg1 = argv[1];
        if (arg1 == "/c" || arg1 == "/C") {
         std::string command;
        for (int i = 2; i < argc; i++) {
            if (i > 2) command += " ";
            command += argv[i];
        }
        
        ShellContext context;
        ShellLogic logic(context);
        logic.runCommand(command);
        return 0;
    }
    }

    // Handle -c flag (Internal Execution)
    if (argc >= 3 && std::string(argv[1]) == "-c") {
        std::string command;
        for (int i = 2; i < argc; i++) {
            if (i > 2) command += " ";
            command += argv[i];
        }
        
        ShellContext context;
        ShellLogic logic(context);
        logic.runCommand(command);
        return 0;
    }

    // 2. Initialize Signal Handler
    SignalHandler::init();
    
    // 3. Initialize Shell API

    
    // Register safe Input Providers
    ShellAPI::setInputProviders(
        [](const std::string& prompt, bool isPassword) -> std::string {
            return InputHandler::readSimpleLine(prompt, isPassword);
        },
        [](const std::string& prompt) -> bool {
            std::string ans = InputHandler::readSimpleLine(prompt, false);
            return (!ans.empty() && (ans[0] == 'y' || ans[0] == 'Y'));
        }
    );
    
    SignalHandler::registerCleanupHandler([]() {
        g_procMgr.killAll();
    });
    
    SignalHandler::registerInterruptHandler([]() {
        if (g_procMgr.killForeground()) {
            std::cout << "\n[SIGINT] Terminated foreground process.\n";
            return; 
        }
        std::cout << "^C\n";
    });

    SignalHandler::registerSuspendHandler([]() {
        if (g_procMgr.suspendForeground()) {
            std::cout << "[Suspended]\n";
        }
    });

    SignalHandler::InputDispatcher::getInstance().registerMouseHandler([](int x, int y, int evType) {
        LinkHandler::get().onMouseEvent(x, y, evType);
    });
    
    auto initialContext = std::make_unique<ShellContext>();
    // We need to initialize context similar to Linuxify constructor
    // (registry paths, etc - currently handled by global g_registry)
    
    /* -c handled early */
    
    // Handle script
    if (argc >= 2 && argv[1][0] != '-') {
        std::vector<std::string> scriptArgs;
        for (int i = 2; i < argc; i++) {
            scriptArgs.push_back(argv[i]);
        }
        ShellLogic logic(*initialContext);
        return logic.runScript(argv[1], scriptArgs);
    }
    
    // Engine Start
    ShellEngine engine;
    
    // Set SAAO session properties in Context
    initialContext->sessionId = g_sessionManager.currentSessionId;
    initialContext->sessionName = g_sessionManager.currentSessionName;
    
    try {
        engine.execute(std::make_unique<StateBoot>(), *initialContext);
    } catch (const Bash::ExitException& e) {
        return e.code;
    }
    
    return 0;
}