myshell.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>
#include <signal.h>
#include <dirent.h>
#include <termios.h>
#include <ctype.h>
#include <sys/time.h>
#include <time.h>

#define MAX_INPUT 1024
#define MAX_ARGS 64
#define MAX_PIPES 10
#define MAX_COMPLETIONS 256
#define MAX_HISTORY 1000
#define MAX_ALIASES 100
#define MAX_BOOKMARKS 50
#define MAX_NOTES 200

// Terminal settings
struct termios orig_termios;

// Command history
char* history[MAX_HISTORY];
int history_count = 0;
int history_index = 0;

// Aliases
typedef struct {
    char* name;
    char* value;
} Alias;

Alias aliases[MAX_ALIASES];
int alias_count = 0;

// Directory bookmarks
typedef struct {
    char* name;
    char* path;
} Bookmark;

Bookmark bookmarks[MAX_BOOKMARKS];
int bookmark_count = 0;

// Function prototypes
void display_prompt();
char* read_input_with_completion();
char** parse_input(char* input);
int execute_command(char** args);
int execute_piped_commands(char** args);
void handle_redirection(char** args);
int builtin_cd(char** args);
int builtin_exit(char** args);
int builtin_help(char** args);
int builtin_alias(char** args);
int builtin_mark(char** args);
int builtin_jump(char** args);
int builtin_marks(char** args);
int builtin_unmark(char** args);
int builtin_note(char** args);
int builtin_notes(char** args);
int builtin_clearnotes(char** args);
int builtin_delnote(char** args);
int builtin_exec(char** args);
int builtin_source(char** args);
int builtin_type(char** args);
int is_arithmetic_expression(char* str);
double evaluate_expression(char* expr);
void load_myshellrc();
void add_alias(char* name, char* value);
char* get_alias(char* name);
char* expand_aliases(char* input);
void load_bookmarks();
void save_bookmarks();
void add_bookmark(char* name, char* path);
char* get_bookmark(char* name);
void save_note(char* note);
void display_notes();
char** get_completions(char* partial, int* count);
char** get_command_completions(char* partial, int* count);
char** get_file_completions(char* partial, int* count);
void enable_raw_mode();
void disable_raw_mode();
void add_to_history(char* cmd);
void save_history_to_file();
void load_history_from_file();

// Built-in command names
char* builtin_names[] = {
    "cd",
    "exit",
    "help",
    "alias",
    "mark",
    "jump",
    "marks",
    "unmark",
    "note",
    "notes",
    "clearnotes",
    "delnote",
    "exec",
    "source",
    "type"
};

// Built-in command functions
int (*builtin_funcs[])(char**) = {
    &builtin_cd,
    &builtin_exit,
    &builtin_help,
    &builtin_alias,
    &builtin_mark,
    &builtin_jump,
    &builtin_marks,
    &builtin_unmark,
    &builtin_note,
    &builtin_notes,
    &builtin_clearnotes,
    &builtin_delnote,
    &builtin_exec,
    &builtin_source,
    &builtin_type
};

int num_builtins() {
    return sizeof(builtin_names) / sizeof(char*);
}

// Built-in: cd
int builtin_cd(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: expected argument to \"cd\"\n");
    } else {
        if (chdir(args[1]) != 0) {
            perror("myshell");
        }
    }
    return 1;
}

// Built-in: exit
int builtin_exit(char** args) {
    return 0;
}

// Built-in: help
int builtin_help(char** args) {
    printf("MyShell - A Simple Unix Shell\n");
    printf("Type program names and arguments, then press enter.\n");
    printf("Built-in commands:\n");
    for (int i = 0; i < num_builtins(); i++) {
        printf("  %s\n", builtin_names[i]);
    }
    printf("\nFeatures:\n");
    printf("  - Command execution\n");
    printf("  - Input/Output redirection (< and >)\n");
    printf("  - Piping (|)\n");
    printf("  - Tab completion for commands and files\n");
    printf("  - Command history with UP/DOWN arrows\n");
    printf("  - Arithmetic evaluation (e.g., 2+3, 10*5, 100/4)\n");
    printf("  - Cursor navigation with LEFT/RIGHT arrows\n");
    printf("  - Word-by-word navigation with CTRL+LEFT/RIGHT\n");
    printf("  - Double-tap ESC to add 'sudo' at the beginning!\n");
    printf("  - Aliases support via ~/.myshellrc\n");
    printf("\nKeyboard Shortcuts:\n");
    printf("  - TAB: Auto-completion\n");
    printf("  - UP/DOWN: Navigate history\n");
    printf("  - LEFT/RIGHT: Move cursor character by character\n");
    printf("  - CTRL+LEFT/RIGHT: Move cursor word by word\n");
    printf("  - ESC ESC (double tap): Add 'sudo' at the beginning\n");
    printf("  - BACKSPACE: Delete character before cursor\n");
    printf("  - CTRL+D: Exit shell\n");
    printf("\n~/.myshellrc Support:\n");
    printf("  - alias name='command': Create command alias\n");
    printf("  - export VAR=value: Set environment variable\n");
    printf("  - # comments: Add comments\n");
    printf("\nDirectory Bookmarks:\n");
    printf("  - mark <name>: Bookmark current directory\n");
    printf("  - jump <name>: Jump to bookmarked directory\n");
    printf("  - marks: List all bookmarks\n");
    printf("  - unmark <name>: Remove bookmark\n");
    printf("\nSession Notes:\n");
    printf("  - note <text>: Add a note\n");
    printf("  - notes: View all notes\n");
    printf("  - delnote <n>: Delete note number N\n");
    printf("  - clearnotes: Clear all notes\n");
    printf("\nAdvanced Commands:\n");
    printf("  - exec <cmd>: Replace shell with command\n");
    printf("  - source <file>: Execute commands from file\n");
    printf("  - type <cmd>: Show command type and location\n");
    return 1;
}

// Built-in: alias
int builtin_alias(char** args) {
    if (args[1] == NULL) {
        // List all aliases
        if (alias_count == 0) {
            printf("No aliases defined.\n");
        } else {
            for (int i = 0; i < alias_count; i++) {
                printf("alias %s='%s'\n", aliases[i].name, aliases[i].value);
            }
        }
    } else {
        // Parse alias definition: alias name='value' or alias name=value
        char* equal = strchr(args[1], '=');
        if (equal) {
            *equal = '\0';
            char* name = args[1];
            char* value = equal + 1;
            
            // Remove quotes if present
            if (value[0] == '\'' || value[0] == '"') {
                value++;
                int len = strlen(value);
                if (len > 0 && (value[len-1] == '\'' || value[len-1] == '"')) {
                    value[len-1] = '\0';
                }
            }
            
            add_alias(name, value);
            printf("alias %s='%s'\n", name, value);
        } else {
            // Show specific alias
            char* value = get_alias(args[1]);
            if (value) {
                printf("alias %s='%s'\n", args[1], value);
            } else {
                printf("myshell: alias: %s: not found\n", args[1]);
            }
        }
    }
    return 1;
}

// Add or update an alias
void add_alias(char* name, char* value) {
    // Check if alias already exists
    for (int i = 0; i < alias_count; i++) {
        if (strcmp(aliases[i].name, name) == 0) {
            free(aliases[i].value);
            aliases[i].value = strdup(value);
            return;
        }
    }
    
    // Add new alias
    if (alias_count < MAX_ALIASES) {
        aliases[alias_count].name = strdup(name);
        aliases[alias_count].value = strdup(value);
        alias_count++;
    } else {
        fprintf(stderr, "myshell: maximum number of aliases reached\n");
    }
}

// Get alias value
char* get_alias(char* name) {
    for (int i = 0; i < alias_count; i++) {
        if (strcmp(aliases[i].name, name) == 0) {
            return aliases[i].value;
        }
    }
    return NULL;
}

// Expand aliases in command
char* expand_aliases(char* input) {
    static char expanded[MAX_INPUT * 2];
    char* result = expanded;
    char temp[MAX_INPUT];
    
    strncpy(temp, input, MAX_INPUT);
    
    // Get first word (command)
    char* first_word = strtok(temp, " \t");
    if (!first_word) {
        return input;
    }
    
    // Check if it's an alias
    char* alias_value = get_alias(first_word);
    if (alias_value) {
        // Replace with alias value
        strcpy(result, alias_value);
        
        // Add remaining arguments
        char* rest = input + strlen(first_word);
        if (*rest) {
            strcat(result, rest);
        }
        return result;
    }
    
    return input;
}

// Load and execute .myshellrc
void load_myshellrc() {
    char* home = getenv("HOME");
    if (!home) return;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshellrc", home);
    
    FILE* f = fopen(filepath, "r");
    if (!f) return;
    
    printf("Loading ~/.myshellrc...\n");
    
    char line[MAX_INPUT];
    int line_num = 0;
    while (fgets(line, sizeof(line), f)) {
        line_num++;
        
        // Remove newline
        line[strcspn(line, "\n")] = 0;
        
        // Skip empty lines and comments
        char* trimmed = line;
        while (*trimmed == ' ' || *trimmed == '\t') trimmed++;
        if (*trimmed == '\0' || *trimmed == '#') continue;
        
        // Handle alias definitions
        if (strncmp(trimmed, "alias ", 6) == 0) {
            char* alias_def = trimmed + 6;
            char* equal = strchr(alias_def, '=');
            if (equal) {
                *equal = '\0';
                char* name = alias_def;
                char* value = equal + 1;
                
                // Trim name
                while (*name == ' ' || *name == '\t') name++;
                char* name_end = name + strlen(name) - 1;
                while (name_end > name && (*name_end == ' ' || *name_end == '\t')) {
                    *name_end = '\0';
                    name_end--;
                }
                
                // Remove quotes from value
                while (*value == ' ' || *value == '\t') value++;
                if (*value == '\'' || *value == '"') {
                    value++;
                    int len = strlen(value);
                    if (len > 0 && (value[len-1] == '\'' || value[len-1] == '"')) {
                        value[len-1] = '\0';
                    }
                }
                
                add_alias(name, value);
            }
        }
        // Handle export statements
        else if (strncmp(trimmed, "export ", 7) == 0) {
            char* export_def = trimmed + 7;
            char* equal = strchr(export_def, '=');
            if (equal) {
                *equal = '\0';
                char* name = export_def;
                char* value = equal + 1;
                
                // Trim name
                while (*name == ' ' || *name == '\t') name++;
                
                // Remove quotes from value
                while (*value == ' ' || *value == '\t') value++;
                if (*value == '\'' || *value == '"') {
                    value++;
                    int len = strlen(value);
                    if (len > 0 && (value[len-1] == '\'' || value[len-1] == '"')) {
                        value[len-1] = '\0';
                    }
                }
                
                setenv(name, value, 1);
            }
        }
        // Execute other commands (like echo)
        else {
            char** args = parse_input(strdup(line));
            if (args[0] != NULL) {
                execute_command(args);
            }
            free(args);
        }
    }
    
    fclose(f);
    printf("Loaded %d aliases from ~/.myshellrc\n", alias_count);
}

// Directory Bookmarks Functions

// Load bookmarks from file
void load_bookmarks() {
    char* home = getenv("HOME");
    if (!home) return;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_bookmarks", home);
    
    FILE* f = fopen(filepath, "r");
    if (!f) return;
    
    char line[MAX_INPUT];
    while (fgets(line, sizeof(line), f) && bookmark_count < MAX_BOOKMARKS) {
        line[strcspn(line, "\n")] = 0;
        
        char* sep = strchr(line, ':');
        if (sep) {
            *sep = '\0';
            bookmarks[bookmark_count].name = strdup(line);
            bookmarks[bookmark_count].path = strdup(sep + 1);
            bookmark_count++;
        }
    }
    
    fclose(f);
}

// Save bookmarks to file
void save_bookmarks() {
    char* home = getenv("HOME");
    if (!home) return;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_bookmarks", home);
    
    FILE* f = fopen(filepath, "w");
    if (!f) return;
    
    for (int i = 0; i < bookmark_count; i++) {
        fprintf(f, "%s:%s\n", bookmarks[i].name, bookmarks[i].path);
    }
    
    fclose(f);
}

// Add or update a bookmark
void add_bookmark(char* name, char* path) {
    // Check if bookmark already exists
    for (int i = 0; i < bookmark_count; i++) {
        if (strcmp(bookmarks[i].name, name) == 0) {
            free(bookmarks[i].path);
            bookmarks[i].path = strdup(path);
            save_bookmarks();
            return;
        }
    }
    
    // Add new bookmark
    if (bookmark_count < MAX_BOOKMARKS) {
        bookmarks[bookmark_count].name = strdup(name);
        bookmarks[bookmark_count].path = strdup(path);
        bookmark_count++;
        save_bookmarks();
    } else {
        fprintf(stderr, "myshell: maximum number of bookmarks reached\n");
    }
}

// Get bookmark path
char* get_bookmark(char* name) {
    for (int i = 0; i < bookmark_count; i++) {
        if (strcmp(bookmarks[i].name, name) == 0) {
            return bookmarks[i].path;
        }
    }
    return NULL;
}

// Built-in: mark
int builtin_mark(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: mark: missing bookmark name\n");
        fprintf(stderr, "Usage: mark <name>\n");
        return 1;
    }
    
    char cwd[1024];
    if (getcwd(cwd, sizeof(cwd)) == NULL) {
        perror("myshell: getcwd");
        return 1;
    }
    
    add_bookmark(args[1], cwd);
    printf("📌 Bookmarked '%s' -> %s\n", args[1], cwd);
    
    return 1;
}

// Built-in: jump
int builtin_jump(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: jump: missing bookmark name\n");
        fprintf(stderr, "Usage: jump <name>\n");
        return 1;
    }
    
    char* path = get_bookmark(args[1]);
    if (path == NULL) {
        fprintf(stderr, "myshell: jump: bookmark '%s' not found\n", args[1]);
        return 1;
    }
    
    if (chdir(path) != 0) {
        perror("myshell: jump");
        return 1;
    }
    
    printf("🚀 Jumped to '%s' (%s)\n", args[1], path);
    
    return 1;
}

// Built-in: marks
int builtin_marks(char** args) {
    if (bookmark_count == 0) {
        printf("No bookmarks defined.\n");
        printf("Use 'mark <name>' to bookmark current directory.\n");
        return 1;
    }
    
    printf("📚 Directory Bookmarks:\n");
    for (int i = 0; i < bookmark_count; i++) {
        printf("  %s -> %s\n", bookmarks[i].name, bookmarks[i].path);
    }
    
    return 1;
}

// Built-in: unmark
int builtin_unmark(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: unmark: missing bookmark name\n");
        fprintf(stderr, "Usage: unmark <name>\n");
        return 1;
    }
    
    for (int i = 0; i < bookmark_count; i++) {
        if (strcmp(bookmarks[i].name, args[1]) == 0) {
            printf("🗑️  Removed bookmark '%s'\n", args[1]);
            
            // Free memory
            free(bookmarks[i].name);
            free(bookmarks[i].path);
            
            // Shift remaining bookmarks
            for (int j = i; j < bookmark_count - 1; j++) {
                bookmarks[j] = bookmarks[j + 1];
            }
            bookmark_count--;
            
            save_bookmarks();
            return 1;
        }
    }
    
    fprintf(stderr, "myshell: unmark: bookmark '%s' not found\n", args[1]);
    return 1;
}

// Session Notes Functions

// Save a note
void save_note(char* note) {
    char* home = getenv("HOME");
    if (!home) return;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_notes", home);
    
    FILE* f = fopen(filepath, "a");
    if (!f) return;
    
    // Get current timestamp
    time_t now = time(NULL);
    struct tm* t = localtime(&now);
    char timestamp[64];
    strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", t);
    
    fprintf(f, "[%s] %s\n", timestamp, note);
    fclose(f);
}

// Display all notes
void display_notes() {
    char* home = getenv("HOME");
    if (!home) return;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_notes", home);
    
    FILE* f = fopen(filepath, "r");
    if (!f) {
        printf("📝 No notes found.\n");
        printf("Use 'note <text>' to add a note.\n");
        return;
    }
    
    printf("📝 Session Notes:\n");
    printf("────────────────────────────────────────\n");
    
    char line[MAX_INPUT];
    int count = 0;
    while (fgets(line, sizeof(line), f)) {
        printf("%3d. %s", ++count, line);
    }
    
    fclose(f);
    
    if (count == 0) {
        printf("No notes found.\n");
    }
    printf("────────────────────────────────────────\n");
    printf("Total: %d note(s)\n", count);
    printf("Use 'delnote <n>' to delete a note or 'clearnotes' to delete all.\n");
}

// Built-in: note
int builtin_note(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: note: missing note text\n");
        fprintf(stderr, "Usage: note <text>\n");
        return 1;
    }
    
    // Reconstruct the full note text
    char note[MAX_INPUT] = "";
    for (int i = 1; args[i] != NULL; i++) {
        if (i > 1) strcat(note, " ");
        strcat(note, args[i]);
    }
    
    save_note(note);
    printf("✅ Note saved: %s\n", note);
    
    return 1;
}

// Built-in: notes
int builtin_notes(char** args) {
    display_notes();
    return 1;
}

// Built-in: clearnotes
int builtin_clearnotes(char** args) {
    char* home = getenv("HOME");
    if (!home) return 1;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_notes", home);
    
    // Ask for confirmation
    printf("⚠️  Are you sure you want to delete ALL notes? (y/n): ");
    fflush(stdout);
    
    char response[10];
    if (fgets(response, sizeof(response), stdin)) {
        if (response[0] == 'y' || response[0] == 'Y') {
            if (remove(filepath) == 0) {
                printf("✅ All notes cleared!\n");
            } else {
                printf("📝 No notes to clear.\n");
            }
        } else {
            printf("❌ Cancelled.\n");
        }
    }
    
    return 1;
}

// Built-in: delnote
int builtin_delnote(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: delnote: missing note number\n");
        fprintf(stderr, "Usage: delnote <n>\n");
        return 1;
    }
    
    int note_num = atoi(args[1]);
    if (note_num <= 0) {
        fprintf(stderr, "myshell: delnote: invalid note number\n");
        return 1;
    }
    
    char* home = getenv("HOME");
    if (!home) return 1;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_notes", home);
    
    FILE* f = fopen(filepath, "r");
    if (!f) {
        printf("📝 No notes found.\n");
        return 1;
    }
    
    // Read all notes into memory
    char notes[MAX_NOTES][MAX_INPUT];
    int count = 0;
    while (fgets(notes[count], MAX_INPUT, f) && count < MAX_NOTES) {
        count++;
    }
    fclose(f);
    
    if (note_num > count) {
        fprintf(stderr, "myshell: delnote: note number %d not found (total: %d)\n", note_num, count);
        return 1;
    }
    
    // Rewrite file without the deleted note
    f = fopen(filepath, "w");
    if (!f) {
        perror("myshell: delnote");
        return 1;
    }
    
    for (int i = 0; i < count; i++) {
        if (i != note_num - 1) {  // Skip the note to delete (convert to 0-based index)
            fprintf(f, "%s", notes[i]);
        }
    }
    
    fclose(f);
    
    printf("✅ Deleted note #%d\n", note_num);
    
    return 1;
}

// Built-in: exec
int builtin_exec(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: exec: missing command\n");
        fprintf(stderr, "Usage: exec <command> [args...]\n");
        return 1;
    }
    
    // Save history before exec
    save_history_to_file();
    
    // Expand aliases
    char* expanded = expand_aliases(args[1]);
    
    // Execute the command, replacing the shell process
    execvp(args[1], &args[1]);
    
    // If we get here, exec failed
    perror("myshell: exec");
    return 1;
}

// Built-in: source
int builtin_source(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: source: missing filename\n");
        fprintf(stderr, "Usage: source <file>\n");
        return 1;
    }
    
    FILE* f = fopen(args[1], "r");
    if (!f) {
        perror("myshell: source");
        return 1;
    }
    
    printf("Sourcing %s...\n", args[1]);
    
    char line[MAX_INPUT];
    int line_num = 0;
    int errors = 0;
    
    while (fgets(line, sizeof(line), f)) {
        line_num++;
        
        // Remove newline
        line[strcspn(line, "\n")] = 0;
        
        // Skip empty lines and comments
        char* trimmed = line;
        while (*trimmed == ' ' || *trimmed == '\t') trimmed++;
        if (*trimmed == '\0' || *trimmed == '#') continue;
        
        // Expand aliases
        char* expanded = expand_aliases(trimmed);
        
        // Check if it's an arithmetic expression
        if (is_arithmetic_expression(expanded)) {
            double result = evaluate_expression(expanded);
            if (result == (int)result) {
                printf("%d\n", (int)result);
            } else {
                printf("%.2f\n", result);
            }
        } else {
            // Parse and execute command
            char** cmd_args = parse_input(strdup(expanded));
            if (cmd_args[0] != NULL) {
                // Execute command silently unless it's echo or similar
                int status = execute_command(cmd_args);
                if (status == 0) {
                    fprintf(stderr, "myshell: source: line %d: command failed\n", line_num);
                    errors++;
                }
            }
            free(cmd_args);
        }
    }
    
    fclose(f);
    
    if (errors > 0) {
        printf("⚠️  Sourced %s with %d error(s)\n", args[1], errors);
    } else {
        printf("✅ Successfully sourced %s\n", args[1]);
    }
    
    return 1;
}

// Built-in: type
int builtin_type(char** args) {
    if (args[1] == NULL) {
        fprintf(stderr, "myshell: type: missing argument\n");
        fprintf(stderr, "Usage: type <command>\n");
        return 1;
    }
    
    char* cmd = args[1];
    
    // Check if it's a builtin
    for (int i = 0; i < num_builtins(); i++) {
        if (strcmp(cmd, builtin_names[i]) == 0) {
            printf("%s is a shell builtin\n", cmd);
            return 1;
        }
    }
    
    // Check if it's an alias
    char* alias_value = get_alias(cmd);
    if (alias_value) {
        printf("%s is aliased to `%s'\n", cmd, alias_value);
        return 1;
    }
    
    // Search in PATH
    char* path_env = getenv("PATH");
    if (!path_env) {
        printf("%s: not found\n", cmd);
        return 1;
    }
    
    char* path = strdup(path_env);
    char* dir = strtok(path, ":");
    
    int found = 0;
    while (dir) {
        char full_path[2048];
        snprintf(full_path, sizeof(full_path), "%s/%s", dir, cmd);
        
        if (access(full_path, X_OK) == 0) {
            printf("%s is %s\n", cmd, full_path);
            found = 1;
            break;
        }
        
        dir = strtok(NULL, ":");
    }
    
    free(path);
    
    if (!found) {
        printf("%s: not found\n", cmd);
    }
    
    return 1;
}

// Check if string is an arithmetic expression
int is_arithmetic_expression(char* str) {
    if (str == NULL || strlen(str) == 0) return 0;
    
    int has_digit = 0;
    int has_operator = 0;
    
    for (int i = 0; str[i] != '\0'; i++) {
        if (isdigit(str[i]) || str[i] == '.') {
            has_digit = 1;
        } else if (str[i] == '+' || str[i] == '-' || str[i] == '*' || 
                   str[i] == '/' || str[i] == '%' || str[i] == '(' || 
                   str[i] == ')' || str[i] == ' ' || str[i] == '^') {
            if (str[i] != ' ' && str[i] != '(' && str[i] != ')') {
                has_operator = 1;
            }
        } else {
            return 0; // Invalid character for arithmetic
        }
    }
    
    return has_digit && has_operator;
}

// Simple expression parser
double parse_number(char** expr) {
    double result = 0;
    double decimal = 0;
    int decimal_places = 0;
    
    while (isdigit(**expr) || **expr == '.') {
        if (**expr == '.') {
            decimal_places = 1;
        } else if (decimal_places > 0) {
            decimal = decimal * 10 + (**expr - '0');
            decimal_places++;
        } else {
            result = result * 10 + (**expr - '0');
        }
        (*expr)++;
    }
    
    if (decimal_places > 1) {
        for (int i = 1; i < decimal_places; i++) {
            decimal /= 10.0;
        }
        result += decimal;
    }
    
    return result;
}

double parse_factor(char** expr);
double parse_term(char** expr);
double parse_expr(char** expr);

double parse_factor(char** expr) {
    while (**expr == ' ') (*expr)++;
    
    if (**expr == '(') {
        (*expr)++;
        double result = parse_expr(expr);
        if (**expr == ')') (*expr)++;
        return result;
    }
    
    if (**expr == '-') {
        (*expr)++;
        return -parse_factor(expr);
    }
    
    if (**expr == '+') {
        (*expr)++;
        return parse_factor(expr);
    }
    
    return parse_number(expr);
}

double parse_power(char** expr) {
    double result = parse_factor(expr);
    
    while (**expr == ' ') (*expr)++;
    
    if (**expr == '^') {
        (*expr)++;
        double exponent = parse_power(expr);
        double base = result;
        result = 1;
        for (int i = 0; i < (int)exponent; i++) {
            result *= base;
        }
    }
    
    return result;
}

double parse_term(char** expr) {
    double result = parse_power(expr);
    
    while (1) {
        while (**expr == ' ') (*expr)++;
        
        if (**expr == '*') {
            (*expr)++;
            result *= parse_power(expr);
        } else if (**expr == '/') {
            (*expr)++;
            double divisor = parse_power(expr);
            if (divisor != 0) {
                result /= divisor;
            } else {
                fprintf(stderr, "Error: Division by zero\n");
                return 0;
            }
        } else if (**expr == '%') {
            (*expr)++;
            int divisor = (int)parse_power(expr);
            if (divisor != 0) {
                result = (int)result % divisor;
            } else {
                fprintf(stderr, "Error: Modulo by zero\n");
                return 0;
            }
        } else {
            break;
        }
    }
    
    return result;
}

double parse_expr(char** expr) {
    double result = parse_term(expr);
    
    while (1) {
        while (**expr == ' ') (*expr)++;
        
        if (**expr == '+') {
            (*expr)++;
            result += parse_term(expr);
        } else if (**expr == '-') {
            (*expr)++;
            result -= parse_term(expr);
        } else {
            break;
        }
    }
    
    return result;
}

// Evaluate arithmetic expression
double evaluate_expression(char* expr) {
    char* ptr = expr;
    return parse_expr(&ptr);
}

// Add command to history
void add_to_history(char* cmd) {
    if (cmd == NULL || strlen(cmd) == 0) return;
    
    // Don't add duplicate of last command
    if (history_count > 0 && strcmp(history[history_count - 1], cmd) == 0) {
        return;
    }
    
    if (history_count < MAX_HISTORY) {
        history[history_count] = strdup(cmd);
        history_count++;
    } else {
        // Shift history and add new command
        free(history[0]);
        for (int i = 0; i < MAX_HISTORY - 1; i++) {
            history[i] = history[i + 1];
        }
        history[MAX_HISTORY - 1] = strdup(cmd);
    }
    history_index = history_count;
}

// Save history to file
void save_history_to_file() {
    char* home = getenv("HOME");
    if (!home) return;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_history", home);
    
    FILE* f = fopen(filepath, "w");
    if (!f) return;
    
    for (int i = 0; i < history_count; i++) {
        fprintf(f, "%s\n", history[i]);
    }
    
    fclose(f);
}

// Load history from file
void load_history_from_file() {
    char* home = getenv("HOME");
    if (!home) return;
    
    char filepath[1024];
    snprintf(filepath, sizeof(filepath), "%s/.myshell_history", home);
    
    FILE* f = fopen(filepath, "r");
    if (!f) return;
    
    char line[MAX_INPUT];
    while (fgets(line, sizeof(line), f) && history_count < MAX_HISTORY) {
        // Remove newline
        line[strcspn(line, "\n")] = 0;
        if (strlen(line) > 0) {
            history[history_count] = strdup(line);
            history_count++;
        }
    }
    
    history_index = history_count;
    fclose(f);
}

// Enable raw mode for terminal
void enable_raw_mode() {
    tcgetattr(STDIN_FILENO, &orig_termios);
    struct termios raw = orig_termios;
    raw.c_lflag &= ~(ECHO | ICANON);
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
}

// Disable raw mode
void disable_raw_mode() {
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_termios);
}

// Get command completions from PATH
char** get_command_completions(char* partial, int* count) {
    char** completions = malloc(MAX_COMPLETIONS * sizeof(char*));
    *count = 0;
    
    // Check built-in commands first
    for (int i = 0; i < num_builtins(); i++) {
        if (strncmp(builtin_names[i], partial, strlen(partial)) == 0) {
            completions[*count] = strdup(builtin_names[i]);
            (*count)++;
        }
    }
    
    // Get PATH
    char* path_env = getenv("PATH");
    if (!path_env) return completions;
    
    char* path = strdup(path_env);
    char* dir = strtok(path, ":");
    
    while (dir && *count < MAX_COMPLETIONS) {
        DIR* d = opendir(dir);
        if (!d) {
            dir = strtok(NULL, ":");
            continue;
        }
        
        struct dirent* entry;
        while ((entry = readdir(d)) && *count < MAX_COMPLETIONS) {
            if (strncmp(entry->d_name, partial, strlen(partial)) == 0) {
                // Check if already in list
                int duplicate = 0;
                for (int i = 0; i < *count; i++) {
                    if (strcmp(completions[i], entry->d_name) == 0) {
                        duplicate = 1;
                        break;
                    }
                }
                if (!duplicate) {
                    completions[*count] = strdup(entry->d_name);
                    (*count)++;
                }
            }
        }
        closedir(d);
        dir = strtok(NULL, ":");
    }
    
    free(path);
    return completions;
}

// Get file/directory completions
char** get_file_completions(char* partial, int* count) {
    char** completions = malloc(MAX_COMPLETIONS * sizeof(char*));
    *count = 0;
    
    char* dir_path = ".";
    char* prefix = partial;
    char temp_path[1024];
    
    // Check if partial contains a path
    char* last_slash = strrchr(partial, '/');
    if (last_slash) {
        strncpy(temp_path, partial, last_slash - partial + 1);
        temp_path[last_slash - partial + 1] = '\0';
        dir_path = temp_path;
        prefix = last_slash + 1;
    }
    
    DIR* d = opendir(dir_path);
    if (!d) return completions;
    
    struct dirent* entry;
    while ((entry = readdir(d)) && *count < MAX_COMPLETIONS) {
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }
        
        if (strncmp(entry->d_name, prefix, strlen(prefix)) == 0) {
            char full_path[2048];
            if (last_slash) {
                snprintf(full_path, sizeof(full_path), "%s%s", dir_path, entry->d_name);
            } else {
                snprintf(full_path, sizeof(full_path), "%s", entry->d_name);
            }
            
            // Add trailing slash for directories
            char path_check[2048];
            snprintf(path_check, sizeof(path_check), "%s/%s", dir_path, entry->d_name);
            DIR* test = opendir(path_check);
            if (test) {
                strcat(full_path, "/");
                closedir(test);
            }
            
            completions[*count] = strdup(full_path);
            (*count)++;
        }
    }
    
    closedir(d);
    return completions;
}

// Get appropriate completions
char** get_completions(char* partial, int* count) {
    // If partial is empty or starts with special chars, get file completions
    if (strlen(partial) == 0 || partial[0] == '.' || partial[0] == '/' || partial[0] == '~') {
        return get_file_completions(partial, count);
    }
    
    // Check if this is the first word (command)
    char input_copy[MAX_INPUT];
    strncpy(input_copy, partial, MAX_INPUT);
    
    // Simple heuristic: if no spaces before cursor position, it's a command
    int has_space = 0;
    for (int i = 0; i < strlen(partial); i++) {
        if (isspace(partial[i])) {
            has_space = 1;
            break;
        }
    }
    
    if (!has_space) {
        return get_command_completions(partial, count);
    } else {
        return get_file_completions(partial, count);
    }
}

// Display shell prompt
// void display_prompt() {
//     char cwd[1024];
//     char hostname[256];
//     char* username = getenv("USER");
    
//     // Get current working directory
//     if (getcwd(cwd, sizeof(cwd)) == NULL) {
//         strcpy(cwd, "?");
//     }
    
//     // Get hostname
//     if (gethostname(hostname, sizeof(hostname)) != 0) {
//         strcpy(hostname, "localhost");
//     }
    
//     // Replace home directory with ~
//     char* home = getenv("HOME");
//     char display_path[1024];
//     if (home && strncmp(cwd, home, strlen(home)) == 0) {
//         snprintf(display_path, sizeof(display_path), "~%s", cwd + strlen(home));
//     } else {
//         strcpy(display_path, cwd);
//     }
    
//     // Get git branch if in a git repo
//     char git_branch[128] = "";
//     FILE* git = popen("git branch --show-current 2>/dev/null", "r");
//     if (git) {
//         if (fgets(git_branch, sizeof(git_branch), git)) {
//             git_branch[strcspn(git_branch, "\n")] = 0;
//         }
//         pclose(git);
//     }
    
//     // Check git status
//     char git_status[16] = "";
//     if (strlen(git_branch) > 0) {
//         FILE* status = popen("git status --porcelain 2>/dev/null | wc -l", "r");
//         if (status) {
//             int changes = 0;
//             if (fscanf(status, "%d", &changes) == 1 && changes > 0) {
//                 strcpy(git_status, "✗");
//             } else {
//                 strcpy(git_status, "✓");
//             }
//             pclose(status);
//         }
//     }
    
//     // Time
//     time_t now = time(NULL);
//     struct tm* t = localtime(&now);
//     char time_str[32];
//     strftime(time_str, sizeof(time_str), "%H:%M:%S", t);
    
//     // Build the prompt with Nerd Font icons
//     // Line 1: User, host, time
//     printf("\033[1;36m╭─\033[0m"); // Cyan top-left corner
//     printf("\033[1;35m \033[0m", username ? username : "user"); // Purple user icon
//     printf("\033[1;37m%s\033[0m", username ? username : "user"); // White username
//     printf("\033[1;30m@\033[0m"); // Gray @
//     printf("\033[1;32m󰒋 \033[0m", hostname); // Green computer icon
//     printf("\033[1;37m%s\033[0m", hostname); // White hostname
//     printf(" \033[1;34m \033[0m", time_str); // Blue clock icon
//     printf("\033[1;90m%s\033[0m", time_str); // Gray time
//     printf("\n");
    
//     // Line 2: Directory and git info
//     printf("\033[1;36m├─\033[0m"); // Cyan middle connector
//     printf("\033[1;34m  \033[0m", display_path); // Blue folder icon
//     printf("\033[1;33m%s\033[0m", display_path); // Yellow path
    
//     if (strlen(git_branch) > 0) {
//         printf(" \033[1;35m \033[0m", git_branch); // Purple git branch icon
//         printf("\033[1;37m%s\033[0m", git_branch); // White branch name
        
//         if (strlen(git_status) > 0) {
//             if (strcmp(git_status, "✓") == 0) {
//                 printf(" \033[1;32m%s\033[0m", git_status); // Green checkmark
//             } else {
//                 printf(" \033[1;31m%s\033[0m", git_status); // Red X
//             }
//         }
//     }
//     printf("\n");
    
//     // Line 3: Input line with prompt character
//     // printf("\033[1;36m╰─\033[0m"); // Cyan bottom-left corner
//     // printf("\033[1;32m❯\033[0m "); // Green arrow
    
//     fflush(stdout);
// }

void display_prompt() {
    char cwd[1024];
    char hostname[256];
    char* username = getenv("USER");
    const char *folder_icon = "";   // nf-fa-folder
    const char *user_icon   = "";   // nf-fa-user
    const char *star_icon   = "✦";   // star / sparkle
    
    // Get current working directory
    if (getcwd(cwd, sizeof(cwd)) == NULL) {
        strcpy(cwd, "?");
    }
    
    // Get hostname
    if (gethostname(hostname, sizeof(hostname)) != 0) {
        strcpy(hostname, "localhost");
    }
    
    // Replace home directory with ~
    char* home = getenv("HOME");
    char display_path[1024];
    if (home && strncmp(cwd, home, strlen(home)) == 0) {
        snprintf(display_path, sizeof(display_path), "~%s", cwd + strlen(home));
    } else {
        strcpy(display_path, cwd);
    }
    
    // Get git branch if in a git repo
    char git_branch[128] = "";
    FILE* git = popen("git branch --show-current 2>/dev/null", "r");
    if (git) {
        if (fgets(git_branch, sizeof(git_branch), git)) {
            git_branch[strcspn(git_branch, "\n")] = 0;
        }
        pclose(git);
    }
    
    // Check git status
    char git_status[16] = "";
    if (strlen(git_branch) > 0) {
        FILE* status = popen("git status --porcelain 2>/dev/null | wc -l", "r");
        if (status) {
            int changes = 0;
            if (fscanf(status, "%d", &changes) == 1 && changes > 0) {
                strcpy(git_status, "✗");
            } else {
                strcpy(git_status, "✓");
            }
            pclose(status);
        }
    }
    
    // Time
    time_t now = time(NULL);
    struct tm* t = localtime(&now);
    char time_str[32];
    strftime(time_str, sizeof(time_str), "%H:%M:%S", t);
    
    // Build the prompt with Nerd Font icons
    // Line 1: User, host, time
    printf("\033[1;36m╭─\033[0m"); // Cyan top-left corner
    printf("\033[1;35m  \033[0m", username ? username : "user"); // Purple user icon
    printf("\033[1;37m%s\033[0m", username ? username : "user"); // White username
    printf("\033[1;32m 󰒋 \033[0m", hostname); // Green computer icon
    printf("\033[1;37m%s\033[0m", hostname); // White hostname
    printf(" \033[1;34m   \033[0m", time_str); // Blue clock icon
    printf("\033[1;90m%s\033[0m", time_str); // Gray time
    printf("\n");
    
    // Line 2: Directory and git info
    printf("\033[1;36m├─  \033[0m"); // Cyan middle connector
    printf("\033[1;34m \033[0m", display_path); // Blue folder icon
    printf("\033[1;33m%s\033[0m", display_path); // Yellow path
    
    if (strlen(git_branch) > 0) {
        printf("\033[1;35m  \033[0m", git_branch); // Purple git branch icon
        printf("\033[1;37m%s\033[0m", git_branch); // White branch name
        
        if (strlen(git_status) > 0) {
            if (strcmp(git_status, "✓") == 0) {
                printf(" \033[1;32m%s\033[0m", git_status); // Green checkmark
            } else {
                printf(" \033[1;31m%s\033[0m", git_status); // Red X
            }
        }
    }
    printf("\n");
    
    // Line 3: Input line with prompt character
    // printf("\033[1;36m╰─\033[0m"); // Cyan bottom-left corner
    // printf("\033[1;32m❯\033[0m "); // Green arrow
    
    fflush(stdout);
}

// Read input with tab completion
char* read_input_with_completion() {
    char* input = malloc(MAX_INPUT);
    int cursor = 0;  // Current cursor position
    int len = 0;     // Total length of input
    int temp_history_index = history_index;
    struct timeval last_esc_time = {0, 0};
    int esc_count = 0;
    
    memset(input, 0, MAX_INPUT);
    enable_raw_mode();
    
    while (1) {
        char c;
        read(STDIN_FILENO, &c, 1);
        
        if (c == '\n') {
            // Enter pressed
            printf("\n");
            break;
        } else if (c == 27) {
            // ESC key or escape sequence
            struct timeval current_time;
            gettimeofday(&current_time, NULL);
            
            // Calculate time difference in milliseconds
            long time_diff = (current_time.tv_sec - last_esc_time.tv_sec) * 1000 +
                           (current_time.tv_usec - last_esc_time.tv_usec) / 1000;
            
            // Check if this is a second ESC within 500ms
            if (time_diff < 500 && esc_count == 1) {
                // Double ESC detected! Add sudo at the beginning
                esc_count = 0;
                
                // Check if sudo is not already there
                if (len < 5 || strncmp(input, "sudo ", 5) != 0) {
                    // Shift everything right to make room for "sudo "
                    if (len + 5 < MAX_INPUT - 1) {
                        memmove(input + 5, input, len);
                        memcpy(input, "sudo ", 5);
                        len += 5;
                        cursor += 5;
                        
                        // Clear only the input line and redraw
                        printf("\r\033[K");
                        input[len] = '\0';
                        printf("%s", input);
                        for (int i = len; i > cursor; i--) {
                            printf("\033[D");
                        }
                        fflush(stdout);
                        
                        printf("\a");  // Beep to confirm
                    }
                }
                continue;
            }
            
            // Wait a bit to see if it's an escape sequence or standalone ESC
            fd_set fds;
            struct timeval timeout;
            FD_ZERO(&fds);
            FD_SET(STDIN_FILENO, &fds);
            timeout.tv_sec = 0;
            timeout.tv_usec = 50000;  // 50ms timeout
            
            int result = select(STDIN_FILENO + 1, &fds, NULL, NULL, &timeout);
            
            if (result > 0) {
                // There's more input, it's an escape sequence (arrow keys, etc.)
                char seq[5];
                if (read(STDIN_FILENO, &seq[0], 1) != 1) continue;
                if (read(STDIN_FILENO, &seq[1], 1) != 1) continue;
                
                if (seq[0] == '[') {
                    if (seq[1] == 'A') {
                        // Up arrow - navigate history
                        if (temp_history_index > 0) {
                            temp_history_index--;
                            
                            // Clear current input line only
                            printf("\r\033[K");
                            
                            // Copy history command to input
                            strcpy(input, history[temp_history_index]);
                            len = strlen(input);
                            cursor = len;
                            printf("%s", input);
                            fflush(stdout);
                        }
                    } else if (seq[1] == 'B') {
                        // Down arrow - navigate history
                        if (temp_history_index < history_count - 1) {
                            temp_history_index++;
                            
                            // Clear current input line only
                            printf("\r\033[K");
                            
                            // Copy history command to input
                            strcpy(input, history[temp_history_index]);
                            len = strlen(input);
                            cursor = len;
                            printf("%s", input);
                            fflush(stdout);
                        } else if (temp_history_index == history_count - 1) {
                            // Go to empty line
                            temp_history_index = history_count;
                            
                            // Clear current input line only
                            printf("\r\033[K");
                            
                            memset(input, 0, MAX_INPUT);
                            len = 0;
                            cursor = 0;
                            fflush(stdout);
                        }
                    } else if (seq[1] == 'C') {
                        // Right arrow - move cursor right
                        if (cursor < len) {
                            cursor++;
                            printf("\033[C");  // Move cursor right
                            fflush(stdout);
                        }
                    } else if (seq[1] == 'D') {
                        // Left arrow - move cursor left
                        if (cursor > 0) {
                            cursor--;
                            printf("\033[D");  // Move cursor left
                            fflush(stdout);
                        }
                    } else if (seq[1] == '1') {
                        // Check for Ctrl+Arrow (extended sequences)
                        if (read(STDIN_FILENO, &seq[2], 1) == 1) {
                            if (seq[2] == ';') {
                                if (read(STDIN_FILENO, &seq[3], 1) == 1 && 
                                    read(STDIN_FILENO, &seq[4], 1) == 1) {
                                    if (seq[3] == '5') {
                                        if (seq[4] == 'C') {
                                            // Ctrl+Right - move word forward
                                            while (cursor < len && input[cursor] != ' ') cursor++;
                                            while (cursor < len && input[cursor] == ' ') cursor++;
                                            
                                            // Redraw input line only
                                            printf("\r\033[K");
                                            printf("%s", input);
                                            for (int i = len; i > cursor; i--) {
                                                printf("\033[D");
                                            }
                                            fflush(stdout);
                                        } else if (seq[4] == 'D') {
                                            // Ctrl+Left - move word backward
                                            if (cursor > 0) cursor--;
                                            while (cursor > 0 && input[cursor] == ' ') cursor--;
                                            while (cursor > 0 && input[cursor - 1] != ' ') cursor--;
                                            
                                            // Redraw input line only
                                            printf("\r\033[K");
                                            printf("%s", input);
                                            for (int i = len; i > cursor; i--) {
                                                printf("\033[D");
                                            }
                                            fflush(stdout);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            } else {
                // No more input, it's a standalone ESC press
                esc_count++;
                gettimeofday(&last_esc_time, NULL);
            }
        } else if (c == '\t') {
            // Tab completion
            input[len] = '\0';
            
            // Find the word to complete
            int word_start = cursor - 1;
            while (word_start >= 0 && !isspace(input[word_start])) {
                word_start--;
            }
            word_start++;
            
            char partial[MAX_INPUT];
            strncpy(partial, input + word_start, cursor - word_start);
            partial[cursor - word_start] = '\0';
            
            int count;
            char** completions = get_completions(partial, &count);
            
            if (count == 1) {
                // Single completion - auto-complete
                int partial_len = strlen(partial);
                int completion_len = strlen(completions[0]);
                
                // Shift remaining text if needed
                if (cursor < len) {
                    memmove(input + word_start + completion_len, 
                           input + cursor, 
                           len - cursor);
                }
                
                // Insert completion
                memcpy(input + word_start, completions[0], completion_len);
                len = len - partial_len + completion_len;
                cursor = word_start + completion_len;
                
                // Add space after completion
                if (cursor == len && len < MAX_INPUT - 1) {
                    input[len++] = ' ';
                    cursor++;
                }
                
                // Redraw input line only
                printf("\r\033[K");
                input[len] = '\0';
                printf("%s", input);
                for (int i = len; i > cursor; i--) {
                    printf("\033[D");
                }
            } else if (count > 1) {
                // Multiple completions - show them
                printf("\n");
                for (int i = 0; i < count; i++) {
                    printf("%s  ", completions[i]);
                    if ((i + 1) % 5 == 0) printf("\n");
                }
                printf("\n");
                
                // Re-display prompt and current input
                display_prompt();
                input[len] = '\0';
                printf("%s", input);
                for (int i = len; i > cursor; i--) {
                    printf("\033[D");
                }
            }
            
            // Free completions
            for (int i = 0; i < count; i++) {
                free(completions[i]);
            }
            free(completions);
            
            fflush(stdout);
        } else if (c == 127 || c == 8) {
            // Backspace
            if (cursor > 0) {
                // Shift text left
                memmove(input + cursor - 1, input + cursor, len - cursor);
                len--;
                cursor--;
                
                // Redraw input line only
                printf("\r\033[K");
                input[len] = '\0';
                printf("%s", input);
                for (int i = len; i > cursor; i--) {
                    printf("\033[D");
                }
                fflush(stdout);
            }
        } else if (c == 4) {
            // Ctrl+D (EOF)
            if (len == 0) {
                disable_raw_mode();
                free(input);
                exit(0);
            }
        } else if (c >= 32 && c <= 126) {
            // Printable character - insert at cursor position
            if (len < MAX_INPUT - 1) {
                // Shift text right to make room
                memmove(input + cursor + 1, input + cursor, len - cursor);
                input[cursor] = c;
                len++;
                cursor++;
                
                // Redraw input line only
                printf("\r\033[K");
                input[len] = '\0';
                printf("%s", input);
                for (int i = len; i > cursor; i--) {
                    printf("\033[D");
                }
                fflush(stdout);
            }
        }
    }
    
    disable_raw_mode();
    input[len] = '\0';
    
    // Add to history if not empty
    if (strlen(input) > 0) {
        add_to_history(input);
    }
    
    return input;
}

// Parse input into arguments
char** parse_input(char* input) {
    int bufsize = MAX_ARGS;
    int position = 0;
    char** tokens = malloc(bufsize * sizeof(char*));
    char* token;
    
    if (!tokens) {
        fprintf(stderr, "myshell: allocation error\n");
        exit(1);
    }
    
    token = strtok(input, " \t\r\n");
    while (token != NULL) {
        tokens[position] = token;
        position++;
        
        if (position >= bufsize) {
            bufsize += MAX_ARGS;
            tokens = realloc(tokens, bufsize * sizeof(char*));
            if (!tokens) {
                fprintf(stderr, "myshell: allocation error\n");
                exit(1);
            }
        }
        
        token = strtok(NULL, " \t\r\n");
    }
    tokens[position] = NULL;
    return tokens;
}

// Handle input/output redirection
void handle_redirection(char** args) {
    for (int i = 0; args[i] != NULL; i++) {
        if (strcmp(args[i], "<") == 0) {
            int fd = open(args[i + 1], O_RDONLY);
            if (fd < 0) {
                perror("myshell");
                exit(1);
            }
            dup2(fd, STDIN_FILENO);
            close(fd);
            args[i] = NULL;
        } else if (strcmp(args[i], ">") == 0) {
            int fd = open(args[i + 1], O_WRONLY | O_CREAT | O_TRUNC, 0644);
            if (fd < 0) {
                perror("myshell");
                exit(1);
            }
            dup2(fd, STDOUT_FILENO);
            close(fd);
            args[i] = NULL;
        }
    }
}

// Execute piped commands
int execute_piped_commands(char** args) {
    int pipe_positions[MAX_PIPES];
    int pipe_count = 0;
    
    // Find all pipe positions
    for (int i = 0; args[i] != NULL; i++) {
        if (strcmp(args[i], "|") == 0) {
            pipe_positions[pipe_count++] = i;
            args[i] = NULL;
        }
    }
    
    if (pipe_count == 0) {
        return -1; // No pipes found
    }
    
    int pipefds[2 * pipe_count];
    for (int i = 0; i < pipe_count; i++) {
        if (pipe(pipefds + i * 2) < 0) {
            perror("pipe");
            return 1;
        }
    }
    
    int cmd_start = 0;
    for (int i = 0; i <= pipe_count; i++) {
        pid_t pid = fork();
        
        if (pid == 0) {
            // Child process
            if (i > 0) {
                dup2(pipefds[(i - 1) * 2], STDIN_FILENO);
            }
            if (i < pipe_count) {
                dup2(pipefds[i * 2 + 1], STDOUT_FILENO);
            }
            
            // Close all pipe fds
            for (int j = 0; j < 2 * pipe_count; j++) {
                close(pipefds[j]);
            }
            
            handle_redirection(&args[cmd_start]);
            execvp(args[cmd_start], &args[cmd_start]);
            perror("myshell");
            exit(1);
        }
        
        cmd_start = pipe_positions[i] + 1;
    }
    
    // Close all pipe fds in parent
    for (int i = 0; i < 2 * pipe_count; i++) {
        close(pipefds[i]);
    }
    
    // Wait for all children
    for (int i = 0; i <= pipe_count; i++) {
        wait(NULL);
    }
    
    return 1;
}

// Execute command
int execute_command(char** args) {
    if (args[0] == NULL) {
        return 1;
    }
    
    // Check for built-in commands
    for (int i = 0; i < num_builtins(); i++) {
        if (strcmp(args[0], builtin_names[i]) == 0) {
            return (*builtin_funcs[i])(args);
        }
    }
    
    // Check for pipes
    if (execute_piped_commands(args) != -1) {
        return 1;
    }
    
    // Execute external command
    pid_t pid = fork();
    
    if (pid == 0) {
        // Child process
        handle_redirection(args);
        execvp(args[0], args);
        perror("myshell");
        exit(1);
    } else if (pid < 0) {
        perror("myshell");
    } else {
        // Parent process
        int status;
        waitpid(pid, &status, 0);
    }
    
    return 1;
}

// Main shell loop
void shell_loop() {
    char* input;
    char** args;
    int status;
    
    do {
        display_prompt();
        input = read_input_with_completion();
        
        // Expand aliases
        char* expanded = expand_aliases(input);
        
        // Check if input is an arithmetic expression
        if (is_arithmetic_expression(expanded)) {
            double result = evaluate_expression(expanded);
            // Check if result is an integer
            if (result == (int)result) {
                printf("%d\n", (int)result);
            } else {
                printf("%.2f\n", result);
            }
            status = 1;
        } else {
            args = parse_input(strdup(expanded));
            status = execute_command(args);
            free(args);
        }
        
        free(input);
    } while (status);
}

int main(int argc, char** argv) {
    // Ignore Ctrl+C in parent
    signal(SIGINT, SIG_IGN);
    
    // Load command history
    load_history_from_file();
    
    // Load directory bookmarks
    load_bookmarks();
    
    printf("MyShell v3.0 - The Fun Shell! ✨\n");
    printf("══════════════════════════════════════════════════════════════\n");
    printf("Type 'help' for more information.\n");
    printf("📌 Bookmarks • 📝 Notes • 🚀 Smart Navigation • ⚡ Fast\n");
    printf("══════════════════════════════════════════════════════════════\n\n");
    
    // Load .myshellrc configuration
    load_myshellrc();
    printf("\n");
    
    shell_loop();
    
    // Save history before exit
    save_history_to_file();
    
    return 0;
}