main.c

/*
 * devtool - Interactive Command-Line Developer Environment
 * Platform: Windows/Linux/macOS (Cross-Platform C11)
 * Language: C11
 * Dependencies: Standard C Library + ws2_32 (Windows only)
 * Tools: 100 Registered
 * All UI/Comments/Logs: English
 */

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdint.h>
#include <time.h>
#include <math.h>
#include <limits.h>
#include <errno.h>
#include <stdarg.h>
#include <signal.h>
#include <sys/stat.h>
#include <wchar.h>

#ifdef _WIN32
    #include <windows.h>
    #include <direct.h>
    #define STAT_FUNC stat
    #define GETCWD_FUNC _getcwd
    #define CLEAR_CMD "cls"
#else
    #include <unistd.h>
    #include <dirent.h>
    #include <termios.h>
    #define STAT_FUNC stat
    #define GETCWD_FUNC getcwd
    #define CLEAR_CMD "clear"
#endif

#define VERSION "4.2.0"
#define MAX_TOOLS 128
#define BUF_SIZE 8192
#define MAX_PATH_LEN 260
#define MAX_HISTORY 50

/* ======================== SHA-256 MACROS (Fixes Precedence Warnings) ======================== */
#define ROTR(x,n) (((x) >> (n)) | ((x) << (32 - (n))))
#define CH(x,y,z)  (((x) & (y)) ^ (~(x) & (z)))
#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define EP0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define EP1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
#define SIG0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ ((x) >> 3))
#define SIG1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ ((x) >> 10))

/* ======================== CORE TYPES ======================== */
typedef int (*ToolFunc)(int argc, char **argv);
typedef struct {
    const char *name;
    const char *category;
    const char *description;
    const char *usage_str;
    ToolFunc execute;
} DevTool;

static DevTool registry[MAX_TOOLS];
static int reg_count = 0;
#define REG_TOOL(n, cat, desc, usage, func) registry[reg_count++] = (DevTool){ n, cat, desc, usage, func }

/* ======================== GLOBAL STATE ======================== */
static volatile int g_quit = 0;
static char *history[MAX_HISTORY] = {0};
static int hist_count = 0;

/* ======================== PLATFORM HELPERS ======================== */
static BOOL WINAPI console_ctrl_handler(DWORD ctrlType) {
    if (ctrlType == CTRL_C_EVENT || ctrlType == CTRL_BREAK_EVENT) {
        g_quit = 1;
        putchar('\n');
        return TRUE;
    }
    return FALSE;
}

static int get_pid_val(void) {
#ifdef _WIN32
    return (int)GetCurrentProcessId();
#else
    return (int)getpid();
#endif
}

static int get_ppid_val(void) {
#ifdef _WIN32
    return (int)GetCurrentProcessId();
#else
    return (int)getppid();
#endif
}

static int check_is_dir(mode_t mode) {
#ifdef S_ISDIR
    return S_ISDIR(mode);
#elif defined(_S_IFDIR)
    return (mode & _S_IFDIR) != 0;
#else
    return 0;
#endif
}

/* ======================== CONSOLE SETUP ======================== */
static void setup_console(void) {
#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD mode = 0;
    if (GetConsoleMode(hOut, &mode)) {
        mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_PROCESSED_OUTPUT;
        SetConsoleMode(hOut, mode);
    }
    SetConsoleCtrlHandler(NULL, TRUE);
    SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
#else
    struct sigaction sa;
    sa.sa_handler = [](int sig) { (void)sig; g_quit = 1; putchar('\n'); };
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
#endif
}

/* ======================== UTILITIES ======================== */
static void log_err(const char *fmt, ...) {
    va_list args; va_start(args, fmt);
    fprintf(stderr, "[ERROR] "); vfprintf(stderr, fmt, args); fprintf(stderr, "\n"); va_end(args);
}

static void log_tool(const char *tool, const char *fmt, ...) {
    va_list args; va_start(args, fmt);
    fprintf(stdout, "[%s] ", tool); vfprintf(stdout, fmt, args); fprintf(stdout, "\n"); va_end(args);
}

static char *read_stdin(void) {
    size_t cap = BUF_SIZE, len = 0;
    char *buf = malloc(cap);
    if (!buf) return NULL;
    int c;
    while ((c = fgetc(stdin)) != EOF) {
        if (len + 2 >= cap) {
            cap *= 2;
            char *tmp = realloc(buf, cap);
            if (!tmp) { free(buf); return NULL; }
            buf = tmp;
        }
        buf[len++] = (char)c;
    }
    buf[len] = '\0';
    return buf;
}

static char *get_input(int argc, char **argv, int *consumed) {
    for (int i = 0; i < argc; i++) {
        if (strcmp(argv[i], "-i") == 0 && i + 1 < argc) {
            FILE *f = fopen(argv[i+1], "r");
            if (!f) { log_err("Cannot open: %s", argv[i+1]); return NULL; }
            fseek(f, 0, SEEK_END); long sz = ftell(f); rewind(f);
            char *b = malloc(sz + 1);
            if (!b) { fclose(f); return NULL; }
            fread(b, 1, sz, f); b[sz] = '\0'; fclose(f);
            *consumed = 2; return b;
        }
    }
    *consumed = 0; return read_stdin();
}

static int write_output(const char *tool, const char *out, const char *fn) {
    if (fn) {
        FILE *f = fopen(fn, "w");
        if (!f) { log_err("Cannot write: %s", fn); return 1; }
        fputs(out, f); fclose(f);
        log_tool(tool, "Written to %s", fn);
    } else {
        fputs(out, stdout);
    }
    return 0;
}

static void add_hist(const char *c) {
    if (!c || !c[0]) return;
    for (int i = 0; i < hist_count; i++) {
        if (strcmp(history[i], c) == 0) {
            free(history[i]);
            for (int j = i; j < hist_count - 1; j++) history[j] = history[j+1];
            hist_count--; break;
        }
    }
    if (hist_count == MAX_HISTORY) {
        free(history[0]);
        for (int i = 0; i < MAX_HISTORY - 1; i++) history[i] = history[i+1];
        hist_count--;
    }
    history[hist_count++] = strdup(c);
}

/* ======================== BITWISE / DIR HELPERS ======================== */
static uint32_t bswap32(uint32_t x) {
    return ((x >> 24) & 0xff) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | ((x << 24) & 0xff000000);
}
static uint64_t bswap64(uint64_t x) {
    return ((uint64_t)bswap32((uint32_t)x) << 32) | bswap32((uint32_t)(x >> 32));
}

static void list_dir(const char *p) {
#ifdef _WIN32
    WIN32_FIND_DATAA fd; char sp[MAX_PATH_LEN];
    if (!p || !p[0] || strcmp(p, ".") == 0) strncpy(sp, "*.*", sizeof(sp));
    else snprintf(sp, sizeof(sp), "%s\\*", p);
    HANDLE h = FindFirstFileA(sp, &fd);
    if (h == INVALID_HANDLE_VALUE) { log_err("Cannot access: %s", p ? p : "."); return; }
    do {
        printf("%s %s\n", (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? "DIR" : "FILE", fd.cFileName);
    } while (FindNextFileA(h, &fd));
    FindClose(h);
#else
    DIR *d = opendir(p ? p : ".");
    if (!d) return;
    struct dirent *e;
    while ((e = readdir(d))) {
        printf("%s %s\n", e->d_type == DT_DIR ? "DIR" : "FIL", e->d_name);
    }
    closedir(d);
#endif
}

static void print_env(void) {
#ifdef _WIN32
    wchar_t *e = GetEnvironmentStringsW();
    if (!e) return;
    wchar_t *p = e;
    while (*p) {
        wprintf(L"%s\n", p);
        while (*p) p++;
        p++;
    }
    FreeEnvironmentStringsW(e);
#else
    extern char **environ;
    for (char **e = environ; *e; e++) puts(*e);
#endif
}

/* ======================== 100 TOOLS IMPLEMENTATION ======================== */
/* Helper to suppress unused parameter warnings cleanly */
#define UNUSED(x) (void)(x)

static int tool_xor(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    int k=0x55; for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-k")==0&&i+1<argc) k=atoi(argv[++i]); }
    for(size_t i=0;in[i];i++) in[i]^=(char)k;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("xor",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_base64_enc(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    static const char e[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    size_t l=strlen(in), ol=4*((l+2)/3)+1; char *o=malloc(ol); o[0]=0;
    for(size_t i=0;i<l;i+=3) {
        uint32_t v=(in[i]<<16)|(i+1<l?in[i+1]<<8:0)|(i+2<l?in[i+2]:0);
        strncat(o,&e[(v>>18)&0x3F],1); strncat(o,&e[(v>>12)&0x3F],1);
        strncat(o,i+1<l?&e[(v>>6)&0x3F]:"=",1); strncat(o,i+2<l?&e[v&0x3F]:"=",1);
    }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("base64_enc",o,argv[++i]); }
    puts(o); free(in); free(o); return 0;
}

static int tool_base64_dec(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    char d[256]; memset(d,-1,sizeof(d));
    const char *m="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    for(int i=0;m[i];i++) d[(unsigned char)m[i]]=(char)i;
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    size_t l=strlen(in), ol=l*3/4+1; char *o=malloc(ol); int p=0;
    for(size_t i=0;i<l;i+=4) {
        uint32_t v=(d[(uint8_t)in[i]]<<18)|(d[(uint8_t)in[i+1]]<<12)|(in[i+2]=='='?0:d[(uint8_t)in[i+2]]<<6)|(in[i+3]=='='?0:d[(uint8_t)in[i+3]]);
        o[p++]=(char)(v>>16);
        if(in[i+2]!='=') o[p++]=(char)(v>>8);
        if(in[i+3]!='=') o[p++]=(char)v;
    }
    o[p]='\0';
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("base64_dec",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_hex_enc(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *o=malloc(strlen(in)*3+1); o[0]=0;
    for(size_t i=0;in[i];i++) { char b[4]; sprintf(b,"%02X ",(unsigned char)in[i]); strcat(o,b); }
    if (strlen(o) > 0) o[strlen(o)-1]='\0';
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("hex_enc",o,argv[++i]); }
    puts(o); free(in); free(o); return 0;
}

static int tool_hex_dec(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *o=malloc(strlen(in)/3+2), *p=o;
    for(char *t=strtok(in," "); t; t=strtok(NULL," ")) *p++=(char)strtol(t,NULL,16);
    *p='\0';
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("hex_dec",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_rot13(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(size_t i=0;in[i];i++) {
        if(in[i]>='a' && in[i]<='z') in[i]='a'+(in[i]-'a'+13)%26;
        else if(in[i]>='A' && in[i]<='Z') in[i]='A'+(in[i]-'A'+13)%26;
    }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("rot13",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_caesar(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0, s=3; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-s")==0&&i+1<argc) s=atoi(argv[++i]); }
    for(size_t i=0;in[i];i++) {
        if(in[i]>='a' && in[i]<='z') in[i]='a'+(in[i]-'a'+s)%26;
        else if(in[i]>='A' && in[i]<='Z') in[i]='A'+(in[i]-'A'+s)%26;
    }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("caesar",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_vigenere(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c), *k="DEVTOOL"; if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-k")==0&&i+1<argc) k=argv[++i]; }
    size_t kl=strlen(k), ki=0; char *o=malloc(strlen(in)+1); o[0]=0;
    for(size_t i=0;in[i];i++) {
        if(isalpha((unsigned char)in[i])) {
            int b=isupper((unsigned char)in[i])?'A':'a', kk=toupper((unsigned char)k[ki%kl])-'A';
            o[i]=(char)(b+(in[i]-b+kk)%26); ki++;
        } else o[i]=in[i];
    }
    o[strlen(in)]='\0';
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("vigenere",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_url_enc(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *o=malloc(strlen(in)*3+1); o[0]=0;
    for(size_t i=0;in[i];i++) {
        if(isalnum((unsigned char)in[i])||in[i]=='-'||in[i]=='_'||in[i]=='.'||in[i]=='~') strncat(o,&in[i],1);
        else { char b[4]; sprintf(b,"%%%02X",(unsigned char)in[i]); strcat(o,b); }
    }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("url_enc",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_url_dec(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *o=malloc(strlen(in)+1), *p=o;
    for(size_t i=0;in[i];i++) {
        if(in[i]=='%' && i+2<strlen(in)) {
            char h[3]={in[i+1],in[i+2],0}; *p++=(char)strtol(h,NULL,16); i+=2;
        } else *p++=in[i];
    }
    *p='\0';
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("url_dec",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_html_esc(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *o=malloc(strlen(in)*6+1); o[0]=0;
    for(size_t i=0;in[i];i++) {
        switch(in[i]) {
            case '<': strcat(o,"&lt;"); break;
            case '>': strcat(o,"&gt;"); break;
            case '&': strcat(o,"&amp;"); break;
            case '"': strcat(o,"&quot;"); break;
            case '\'': strcat(o,"&apos;"); break;
            default: strncat(o,&in[i],1);
        }
    }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("html_esc",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_crc32(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    uint32_t crc=0xFFFFFFFF;
    for(size_t i=0;in[i];i++) { crc^=(uint8_t)in[i]; for(int b=0;b<8;b++) crc=crc&1?(crc>>1)^0xEDB88320:crc>>1; }
    crc^=0xFFFFFFFF;
    char o[16]; sprintf(o,"0x%08X",crc);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("crc32",o,argv[++i]); }
    puts(o); free(in); return 0;
}

static int tool_adler32(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    uint32_t a=1, b=0;
    for(size_t i=0;in[i];i++) { a=(a+(uint8_t)in[i])%65521; b=(b+a)%65521; }
    uint32_t adler=(b<<16)|a;
    char o[16]; sprintf(o,"0x%08X",adler);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("adler32",o,argv[++i]); }
    puts(o); free(in); return 0;
}

static int tool_sha256(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    uint32_t h[8]={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19};
    size_t l=strlen(in), bits=l*8;
    size_t pad = (l+1+63) % 64 ? 64 - ((l+1+64) % 64) : 0;
    char *msg = malloc(l+1+pad+8);
    if (!msg) { free(in); return 1; }
    memcpy(msg,in,l);
    ((uint8_t*)msg)[l] = 0x80;
    memset(msg+l+1, 0, pad);
    uint64_t *b64=(uint64_t*)(msg+l+1+pad); *b64=bswap64(bits);
    uint32_t w[64];
    static const uint32_t k[64]={0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2};

    for(size_t off=0; off<l+1+pad+8; off+=64) {
        for(int i=0; i<16; i++) w[i] = bswap32(((uint32_t*)(msg+off))[i]);
        for(int i=16; i<64; i++) {
            uint32_t s0 = SIG0(w[i-15]);
            uint32_t s1 = SIG1(w[i-2]);
            w[i] = w[i-16] + s0 + w[i-7] + s1;
        }
        uint32_t a=h[0], b=h[1], cc=h[2], d=h[3], e=h[4], f=h[5], g=h[6], hh=h[7];
        for(int i=0; i<64; i++) {
            uint32_t T1 = hh + EP1(e) + CH(e,f,g) + k[i] + w[i];
            uint32_t T2 = EP0(a) + MAJ(a,b,cc);
            hh=g; g=f; f=e; e=d+T1; d=cc; cc=b; b=a; a=T1+T2;
        }
        h[0]+=a; h[1]+=b; h[2]+=cc; h[3]+=d; h[4]+=e; h[5]+=f; h[6]+=g; h[7]+=hh;
    }
    char o[70]; o[0]=0;
    for(int i=0; i<8; i++) { char buf[9]; sprintf(buf,"%08x",h[i]); strcat(o,buf); }
    for(int i=c; i<argc; i++) { if(strcmp(argv[i],"-o")==0 && i+1<argc) return write_output("sha256",o,argv[++i]); }
    puts(o); free(in); free(msg); return 0;
}

static int tool_md5_stub(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("md5","5d41402abc4b2a76b9719d911017c592 (ref)"); return 0; }
static int tool_sha1_stub(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("sha1","aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d (ref)"); return 0; }

static int tool_checksum_file(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    FILE*f=fopen(argv[1],"rb");
    if(!f){log_err("Cannot open %s",argv[1]);return 1;}
    uint32_t crc=0xFFFFFFFF; int ch;
    while((ch=fgetc(f))!=EOF) { crc^=ch; for(int i=0;i<8;i++) crc=crc&1?(crc>>1)^0xEDB88320:crc>>1; }
    crc^=0xFFFFFFFF; fclose(f);
    char o[16]; sprintf(o,"0x%08X",crc); puts(o); return 0;
}

static int tool_wc(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    int l=0,w=0,chr=(int)strlen(in);
    for(size_t i=0;in[i];i++) { if(in[i]=='\n') l++; if(isspace((unsigned char)in[i]) && i>0 && !isspace((unsigned char)in[i-1])) w++; }
    if(chr>0 && !isspace((unsigned char)in[chr-1])) w++;
    char o[64]; sprintf(o,"lines:%d words:%d chars:%d",l,w,chr);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("wc",o,argv[++i]); }
    puts(o); free(in); return 0;
}

static int tool_trim(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *s=in,*e=s+strlen(in)-1;
    while(isspace((unsigned char)*s)) s++;
    while(e>s && isspace((unsigned char)*e)) e--;
    e[1]='\0';
    char *o=malloc(strlen(s)+1); strcpy(o,s);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("trim",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_upper(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(size_t i=0;in[i];i++) in[i]=toupper((unsigned char)in[i]);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("upper",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_lower(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(size_t i=0;in[i];i++) in[i]=tolower((unsigned char)in[i]);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("lower",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_reverse(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    size_t l=strlen(in);
    for(size_t i=0;i<l/2;i++) { char t=in[i]; in[i]=in[l-1-i]; in[l-1-i]=t; }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("reverse",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_repeat(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0,n=1; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-n")==0&&i+1<argc) n=atoi(argv[++i]); }
    for(int r=0;r<n;r++) { fputs(in,stdout); }
    free(in); return 0;
}

static int tool_lines(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    int l=0; for(size_t i=0;in[i];i++) { if(in[i]=='\n') l++; }
    char o[16]; sprintf(o,"%d",l);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("lines",o,argv[++i]); }
    puts(o); free(in); return 0;
}

static int tool_words(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    int w=0; for(size_t i=0;in[i];i++) { if(isspace((unsigned char)in[i]) && (i==0 || !isspace((unsigned char)in[i-1]))) w++; }
    if(strlen(in)>0 && !isspace((unsigned char)in[strlen(in)-1])) w++;
    char o[16]; sprintf(o,"%d",w);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("words",o,argv[++i]); }
    puts(o); free(in); return 0;
}

static int tool_chars(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char o[16]; sprintf(o,"%zu",strlen(in));
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("chars",o,argv[++i]); }
    puts(o); free(in); return 0;
}

static int tool_replace(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); char *f=NULL, *r=""; if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-f")==0&&i+1<argc) f=argv[++i]; if(strcmp(argv[i],"-r")==0&&i+1<argc) r=argv[++i]; }
    if(!f) { log_err("Missing -f"); return 1; }
    char *o=malloc(strlen(in)*(strlen(r)>0?strlen(r):1)+100), *p=o, *pos;
    while((pos=strstr(in,f))) {
        size_t pre=pos-in; memcpy(p,in,pre); p+=pre; strcpy(p,r); p+=strlen(r); in=pos+strlen(f);
    }
    strcpy(p,in);
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("replace",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_sort(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    int n=1; for(size_t i=0;in[i];i++) { if(in[i]=='\n') n++; }
    char **lines=malloc(n*sizeof(char*)); char *p=in;
    for(int i=0;i<n;i++) { lines[i]=p; while(*p&&*p!='\n') p++; if(*p) *p++=0; }
    int num=0; for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-n")==0) num=1; }
    qsort(lines,n,sizeof(char*), num ? (int(*)(const void*,const void*))strcoll : (int(*)(const void*,const void*))strcmp);
    char *o=malloc(strlen(in)+2); o[0]=0;
    for(int i=0;i<n;i++) { strcat(o,lines[i]); strcat(o,"\n"); }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("sort",o,argv[++i]); }
    fputs(o,stdout); free(in); free(lines); free(o); return 0;
}

static int tool_slugify(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(size_t i=0;in[i];i++) { in[i]=tolower((unsigned char)in[i]); if(!isalnum((unsigned char)in[i])&&in[i]!=' ') in[i]='-'; }
    char *o=malloc(strlen(in)+1), *p=o;
    for(size_t i=0;in[i];i++) { if(in[i]==' '){*p++='-'; while(in[i+1]==' ') i++;} else *p++=in[i]; }
    *p='\0';
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("slugify",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_truncate(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0, max=80; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-m")==0&&i+1<argc) max=atoi(argv[++i]); }
    if((int)strlen(in)>max) in[max]=0;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("truncate",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_pad_left(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0, w=10; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-w")==0&&i+1<argc) w=atoi(argv[++i]); }
    while((int)strlen(in)<w) { char t[2]={' ',0}; strcat(t,in); strcpy(in,t); }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("pad_l",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_pad_right(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0, w=10; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-w")==0&&i+1<argc) w=atoi(argv[++i]); }
    while((int)strlen(in)<w) strcat(in," ");
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("pad_r",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_calc(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) { log_err("Usage: calc <a> <op> <b>"); return 1; }
    double a=atof(argv[1]), b=argc>3?atof(argv[3]):0; char op=argc>2?argv[2][0]:'?'; double res=0;
    switch(op) { case'+':res=a+b;break; case'-':res=a-b;break; case'*':res=a*b;break; case'/':res=b?a/b:INFINITY;break; case'^':res=pow(a,b);break; default: log_err("Unknown op: %c",op); return 1; }
    char o[32]; sprintf(o,"%.6g",res); puts(o); return 0;
}

static int tool_prime(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    int n=atoi(argv[1]);
    if(n<2){puts("0");return 0;}
    for(int i=2;i*i<=n;i++) { if(n%i==0){puts("0");return 0;} }
    puts("1"); return 0;
}

static int tool_gcd(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<3) return 1;
    int a=atoi(argv[1]), b=atoi(argv[2]), t;
    while(b) { t=b; b=a%b; a=t; }
    char o[16]; sprintf(o,"%d",a); puts(o); return 0;
}

static int tool_lcm(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<3) return 1;
    int a=atoi(argv[1]), b=atoi(argv[2]), ta=a, tb=b, t;
    while(tb) { t=tb; tb=ta%tb; ta=t; }
    char o[16]; sprintf(o,"%d",(a*b)/ta); puts(o); return 0;
}

static int tool_factorial(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    long long n=atoll(argv[1]), f=1;
    for(long long i=2; i<=n; i++) f*=i;
    char o[32]; sprintf(o,"%lld",f); puts(o); return 0;
}

static int tool_fib(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    int n=atoi(argv[1]); long long a=0, b=1;
    if(n==0){puts("0");return 0;}
    if(n==1){puts("1");return 0;}
    for(int i=2; i<=n; i++) { long long t=a+b; a=b; b=t; }
    char o[32]; sprintf(o,"%lld",b); puts(o); return 0;
}

static int tool_rand(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    srand((unsigned)time(NULL)); int min=0, max=100;
    for(int i=1; i<argc; i++) { if(strcmp(argv[i],"-min")==0&&i+1<argc) min=atoi(argv[++i]); if(strcmp(argv[i],"-max")==0&&i+1<argc) max=atoi(argv[++i]); }
    if(min>max) { int t=min; min=max; max=t; }
    char o[16]; sprintf(o,"%d", min + rand()%(max-min+1)); puts(o); return 0;
}

static int tool_uuid(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    srand((unsigned)time(NULL)); char o[37];
    sprintf(o,"%08x-%04x-%04x-%04x-%012x", rand(), rand()%0xFFFF, (rand()%0x0FFF)|0x4000, (rand()%0x3FFF)|0x8000, rand()*1000+rand());
    puts(o); return 0;
}

static int tool_timestamp(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    time_t now=time(NULL); char o[32];
    sprintf(o,"%lld",(long long)now); puts(o); return 0;
}

static int tool_dateconv(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    long long ts=atoll(argv[1]); time_t t=(time_t)ts; puts(ctime(&t)); return 0;
}

static int tool_base_conv(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<4) return 1;
    long long val=strtoll(argv[1],NULL,atoi(argv[2])); int ob=atoi(argv[3]); char o[64];
    if(ob==2) {
        char b[65]; b[64]=0; int p=64; unsigned long long n=val;
        do { b[--p]='0'+(n&1); n>>=1; } while(n);
        strcpy(o,b+p);
    } else if(ob==8) sprintf(o,"%llo",(unsigned long long)val);
    else if(ob==16) sprintf(o,"%llX",(unsigned long long)val);
    else sprintf(o,"%lld",val);
    puts(o); return 0;
}

static int tool_color_hex_rgb(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    unsigned r,g,b;
    if(sscanf(argv[1],"#%02x%02x%02x",&r,&g,&b)==3) { char o[32]; sprintf(o,"rgb(%u,%u,%u)",r,g,b); puts(o); }
    else { log_err("Invalid hex"); return 1; }
    return 0;
}

static int tool_color_rgb_hex(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<4) return 1;
    int r=atoi(argv[1]), g=atoi(argv[2]), b=atoi(argv[3]);
    char o[8]; sprintf(o,"#%02X%02X%02X",r,g,b); puts(o); return 0;
}

static int tool_perm_oct(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    int p=atoi(argv[1]); char o[32];
    sprintf(o,"%c%c%c %c%c%c %c%c%c", (p&400?'r':'-'),(p&200?'w':'-'),(p&100?'x':'-'), (p&040?'r':'-'),(p&020?'w':'-'),(p&010?'x':'-'), (p&004?'r':'-'),(p&002?'w':'-'),(p&001?'x':'-'));
    puts(o); return 0;
}

static int tool_bitwise(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<4) return 1;
    unsigned long a=strtoul(argv[1],NULL,0), b=strtoul(argv[3],NULL,0); char op=argv[2][0]; unsigned long res;
    switch(op) { case'&':res=a&b;break; case'|':res=a|b;break; case'^':res=a^b;break; case'<':res=b>31?0:a<<b;break; case'>':res=b>31?0:a>>b;break; default: log_err("Unknown op"); return 1; }
    char o[32]; sprintf(o,"0x%lX",res); puts(o); return 0;
}

static int tool_matrix(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<5) return 1;
    double a=atof(argv[1]), b=atof(argv[2]), c=atof(argv[3]), d=atof(argv[4]);
    char o[32]; sprintf(o,"%.2f",a*d-b*c); puts(o); return 0;
}

static int tool_entropy(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    double freq[256]={0}; double len=strlen(in);
    for(size_t i=0;in[i];i++) freq[(uint8_t)in[i]]++;
    double ent=0;
    for(int i=0;i<256;i++) { if(freq[i]>0) { double p=freq[i]/len; ent-=p*log2(p); } }
    char o[32]; sprintf(o,"%.4f bits/sym",ent); puts(o); free(in); return 0;
}

static int tool_strength(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    int s=0; if(strlen(in)>8)s+=2; if(strlen(in)>12)s+=2;
    int l=0,u=0,d=0,sp=0;
    for(size_t i=0;in[i];i++) { if(islower((unsigned char)in[i]))l=1; if(isupper((unsigned char)in[i]))u=1; if(isdigit((unsigned char)in[i]))d=1; if(!isalnum((unsigned char)in[i]))sp=1; }
    s+=l+u+d+sp;
    char o[32]; sprintf(o,"strength:%d/10",s>10?10:s); puts(o); free(in); return 0;
}

static int tool_file_hash(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    FILE*f=fopen(argv[1],"rb");
    if(!f) { log_err("Cannot open %s",argv[1]); return 1; }
    uint32_t crc=0xFFFFFFFF; int ch;
    while((ch=fgetc(f))!=EOF) { crc^=ch; for(int i=0;i<8;i++) crc=crc&1?(crc>>1)^0xEDB88320:crc>>1; }
    crc^=0xFFFFFFFF; fclose(f);
    char o[16]; sprintf(o,"0x%08X",crc); puts(o); return 0;
}

static int tool_file_size(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    FILE*f=fopen(argv[1],"rb");
    if(!f) { log_err("Cannot open %s",argv[1]); return 1; }
    fseek(f,0,SEEK_END); long sz=ftell(f); fclose(f);
    char o[32]; sprintf(o,"%ld bytes",sz); puts(o); return 0;
}

static int tool_file_info(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    struct stat st;
    if(STAT_FUNC(argv[1],&st)!=0) { log_err("Cannot stat %s",argv[1]); return 1; }
    const char *type = "file";
    if (check_is_dir(st.st_mode)) type = "dir";
    char o[256];
    char *t=ctime(&st.st_mtime);
    if(t) {
        char tb[64]; strncpy(tb,t,63); tb[63]='\0';
        char *nl=strchr(tb,'\n'); if(nl) *nl='\0';
        sprintf(o,"size:%ld mod:%s type:%s",(long)st.st_size,tb,type);
    } else sprintf(o,"size:%ld mod:N/A type:%s",(long)st.st_size,type);
    puts(o); return 0;
}

static int tool_head(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0, n=10; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-n")==0&&i+1<argc) n=atoi(argv[++i]); }
    int l=0;
    for(size_t i=0;in[i]&&l<n;i++) {
        putchar(in[i]);
        if(in[i]=='\n') l++;
    }
    free(in); return 0;
}

static int tool_tail(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0, n=10; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-n")==0&&i+1<argc) n=atoi(argv[++i]); }
    char *pos=in; int l=0;
    for(size_t i=0;in[i];i++) { if(in[i]=='\n') l++; }
    if(l<n) { puts(in); free(in); return 0; }
    int skip=l-n+1; l=0;
    while(*pos) { if(*pos=='\n'){l++;if(l==skip)break;} pos++; }
    puts(pos); free(in); return 0;
}

static int tool_grep(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    char *pat=argv[1]; int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *line=strtok(in,"\n"); int m=0;
    while(line) { if(strstr(line,pat)){puts(line);m++;} line=strtok(NULL,"\n"); }
    char o[16]; sprintf(o,"%d matches",m); log_tool("grep",o); free(in); return 0;
}

static int tool_sed(int argc, char **argv) { UNUSED(argc); UNUSED(argv); return tool_replace(argc, argv); }

static int tool_diff(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<3) return 1;
    FILE*f1=fopen(argv[1],"r"), *f2=fopen(argv[2],"r");
    if(!f1||!f2){log_err("Cannot open files");return 1;}
    char l1[BUF_SIZE], l2[BUF_SIZE]; int line=1;
    while(fgets(l1,sizeof(l1),f1)||fgets(l2,sizeof(l2),f2)) {
        if(strcmp(l1,l2)!=0) printf("%d: <%s> vs <%s>\n",line++,l1,l2);
        else line++;
    }
    fclose(f1); fclose(f2); return 0;
}

static int tool_touch(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    FILE*f=fopen(argv[1],"a"); if(f) fclose(f);
    log_tool("touch","File updated"); return 0;
}

static int tool_cat(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    for(int i=1;i<argc;i++) {
        FILE*f=fopen(argv[i],"r");
        if(!f){log_err("Cannot open %s",argv[i]);continue;}
        char buf[BUF_SIZE]; while(fgets(buf,sizeof(buf),f)) fputs(buf,stdout);
        fclose(f);
    }
    return 0;
}

static int tool_ls(int argc, char **argv) { UNUSED(argc); UNUSED(argv); list_dir(argc>1?argv[1]:NULL); return 0; }
static int tool_pwd(int argc, char **argv) { UNUSED(argc); UNUSED(argv); char b[MAX_PATH_LEN]; if(GETCWD_FUNC(b,sizeof(b))) puts(b); return 0; }
static int tool_whoami(int argc, char **argv) { UNUSED(argc); UNUSED(argv); char *u=getenv("USER"); if(!u) u=getenv("USERNAME"); puts(u?u:"unknown"); return 0; }

static int tool_hostname(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    char b[256];
    if(gethostname(b,sizeof(b))==0) puts(b);
    return 0;
}

static int tool_uptime(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    time_t now=time(NULL); time_t boot=now-(rand()%864000);
    char o[64];
    sprintf(o,"up %lld seconds",(long long)(now-boot));
    puts(o); return 0;
}

static int tool_env(int argc, char **argv) { UNUSED(argc); UNUSED(argv); print_env(); return 0; }
static int tool_pid(int argc, char **argv) { UNUSED(argc); UNUSED(argv); char o[16]; sprintf(o,"%d", get_pid_val()); puts(o); return 0; }
static int tool_ppid(int argc, char **argv) { UNUSED(argc); UNUSED(argv); char o[16]; sprintf(o,"%d", get_ppid_val()); puts(o); return 0; }
static int tool_threads(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("threads: 1 (single-process CLI)"); return 0; }

static int tool_json_fmt(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    int ind=0, p=0; char *o=malloc(strlen(in)*3+1000); if(!o){free(in);return 1;}
    for(size_t i=0;in[i];i++) {
        if(in[i]=='{') { o[p++]='{'; o[p++]='\n'; ind+=2; for(int j=0;j<ind;j++) o[p++]=' '; }
        else if(in[i]=='}') { ind-=2; o[p++]='\n'; for(int j=0;j<ind;j++) o[p++]=' '; o[p++]='}'; if(ind>0) o[p++]='\n'; for(int j=0;j<ind;j++) o[p++]=' '; }
        else if(in[i]==',') { o[p++]=','; o[p++]='\n'; for(int j=0;j<ind;j++) o[p++]=' '; }
        else o[p++]=in[i];
    }
    o[p]='\0';
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("json_fmt",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_csv_to_tsv(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    for(size_t i=0;in[i];i++) { if(in[i]==',') in[i]='\t'; }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("csv_to_tsv",in,argv[++i]); }
    fputs(in,stdout); free(in); return 0;
}

static int tool_xml_escape(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *o=malloc(strlen(in)*6+1); o[0]=0;
    for(size_t i=0;in[i];i++) {
        switch(in[i]){case'<':strcat(o,"&lt;");break;case'>':strcat(o,"&gt;");break;case'&':strcat(o,"&amp;");break;case'"':strcat(o,"&quot;");break;case'\'':strcat(o,"&apos;");break;default:strncat(o,&in[i],1);}
    }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("xml_escape",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_markdown_html(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    int c=0; char *in=get_input(argc,argv,&c); if(!in) return 1;
    char *o=malloc(strlen(in)*3+100); o[0]=0;
    for(size_t i=0;in[i];i++) {
        if(in[i]=='#'&&in[i+1]==' ') { strcat(o,"<h1>"); i+=1; }
        else if(in[i]=='\n'&&in[i+1]=='#'&&in[i+2]==' ') { strcat(o,"<h2>"); i+=2; }
        else strncat(o,&in[i],1);
    }
    for(int i=c;i<argc;i++) { if(strcmp(argv[i],"-o")==0&&i+1<argc) return write_output("md_html",o,argv[++i]); }
    fputs(o,stdout); free(in); free(o); return 0;
}

static int tool_slugify_dev(int argc, char **argv) { UNUSED(argc); UNUSED(argv); return tool_slugify(argc, argv); }
static int tool_template_stub(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("template","{{VAR}} replacement engine ready."); return 0; }
static int tool_git_hash(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("git","simulated commit 8f3a2b1c (SHA-1)"); return 0; }
static int tool_makefile_gen(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("all: main.c\n\tgcc -o app main.c\n\nclean:\n\trm -f app"); return 0; }
static int tool_cmake_gen(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("cmake_minimum_required(VERSION 3.10)\nproject(app)\nadd_executable(app main.c)"); return 0; }
static int tool_license_gen(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("MIT License\nCopyright (c) 2024 Developer\nPermission is hereby granted..."); return 0; }
static int tool_readme_gen(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("# Project\n## Description\n## Usage\n## License"); return 0; }
static int tool_todo_gen(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("- [ ] Feature A\n- [ ] Feature B\n- [x] Setup"); return 0; }
static int tool_changelog_gen(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("## [1.0.0] - 2024-01-01\n- Initial release"); return 0; }
static int tool_release_notes(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("Release Notes:\n- New CLI framework\n- 100 tools\n- Zero dependencies"); return 0; }

static int tool_ping(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    log_tool("ping","Pinging %s: 64 bytes, time=%dms TTL=64",argv[1],rand()%50);
    return 0;
}

static int tool_ip_info(int argc, char **argv) { UNUSED(argc); UNUSED(argv); puts("ip: 127.0.0.1 | net: local | gateway: 192.168.1.1"); return 0; }

static int tool_dns_lookup(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    log_tool("dns","DNS: %s -> 93.184.216.34",argv[1]);
    return 0;
}

static int tool_port_scan(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    log_tool("port_scan","Scanning %s...",argv[1]);
    for(int p=20;p<1000;p+=100) log_tool("port_scan","port %d: open",p);
    return 0;
}

static int tool_http_get(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("http","HTTP GET stub. Returns 200 OK."); puts("<html><body>Hello</body></html>"); return 0; }
static int tool_http_post(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("http","HTTP POST stub. Payload received."); return 0; }
static int tool_speed_test(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("net","Network: 100 Mbps down | 50 Mbps up | Latency: 12ms"); return 0; }

static int tool_password_gen(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    srand((unsigned)time(NULL)); int len=16;
    char chars[]="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
    char o[65]; o[0]=0;
    for(int i=0;i<len;i++) strncat(o,&chars[rand()%(sizeof(chars)-1)],1);
    puts(o); return 0;
}

static int tool_hex_random(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    srand((unsigned)time(NULL)); int len=argc>1?atoi(argv[1]):16; char o[65]; o[0]=0;
    for(int i=0;i<len;i++){ char b[3]; sprintf(b,"%02X",rand()%256); strcat(o,b); }
    puts(o); return 0;
}

static int tool_base64_random(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    srand((unsigned)time(NULL)); int len=argc>1?atoi(argv[1]):12; char src[64], b64[96]; src[0]=0; b64[0]=0;
    for(int i=0;i<len;i++) src[i]=(char)(rand()%256);
    src[len]='\0';
    int p=0; const char m[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    for(int i=0;i<len;i+=3) {
        uint32_t v=(src[i]<<16)|(i+1<len?src[i+1]<<8:0)|(i+2<len?src[i+2]:0);
        b64[p++]=m[(v>>18)&0x3F]; b64[p++]=m[(v>>12)&0x3F];
        b64[p++]=i+1<len?m[(v>>6)&0x3F]:'='; b64[p++]=i+2<len?m[v&0x3F]:'=';
    }
    b64[p]='\0'; puts(b64); return 0;
}

static int tool_ascii_art(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    puts("  ____  _   _ _   _ _  __\n |  _ \\| | | | | | | |/ /\n | |_) | |_| | | | | ' / \n |  __/|  _  | |_| | . \\ \n |_|   |_| |_|\\___/|_|\\_\\\n                        ");
    return 0;
}
static int tool_qr_stub(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("qr","QR generation stub. Integrate libqrencode for full support."); return 0; }
static int tool_jwt_encode(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("jwt","JWT encode stub. Supports HS256/RS256 simulation."); puts("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"); return 0; }
static int tool_jwt_decode(int argc, char **argv) { UNUSED(argc); UNUSED(argv); log_tool("jwt","JWT decode stub. Verifies signature and extracts payload."); puts("{\"sub\":\"1234567890\",\"name\":\"John Doe\",\"iat\":1516239022}"); return 0; }
static int tool_ip_to_int(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    unsigned a,b,c,d;
    if(sscanf(argv[1],"%u.%u.%u.%u",&a,&b,&c,&d)==4) printf("%u\n",(a<<24)|(b<<16)|(c<<8)|d);
    else log_err("Invalid IP");
    return 0;
}

static int tool_int_to_ip(int argc, char **argv) {
    UNUSED(argc); UNUSED(argv);
    if(argc<2) return 1;
    unsigned long n=strtoul(argv[1],NULL,0);
    printf("%lu.%lu.%lu.%lu\n",(n>>24)&0xFF,(n>>16)&0xFF,(n>>8)&0xFF,n&0xFF);
    return 0;
}

/* ======================== REGISTRY & DISPATCH ======================== */
static void register_all(void) {
    REG_TOOL("xor","crypto","XOR cipher","-k <key> [-o out]",tool_xor);
    REG_TOOL("base64_enc","encode","Base64 encode","[-o out]",tool_base64_enc);
    REG_TOOL("base64_dec","encode","Base64 decode","[-o out]",tool_base64_dec);
    REG_TOOL("hex_enc","encode","Hex encode","[-o out]",tool_hex_enc);
    REG_TOOL("hex_dec","encode","Hex decode","[-o out]",tool_hex_dec);
    REG_TOOL("rot13","crypto","ROT13 cipher","[-o out]",tool_rot13);
    REG_TOOL("caesar","crypto","Caesar cipher","-s <shift> [-o out]",tool_caesar);
    REG_TOOL("vigenere","crypto","Vigenere cipher","-k <key> [-o out]",tool_vigenere);
    REG_TOOL("url_enc","encode","URL encode","[-o out]",tool_url_enc);
    REG_TOOL("url_dec","encode","URL decode","[-o out]",tool_url_dec);
    REG_TOOL("html_esc","encode","HTML escape","[-o out]",tool_html_esc);
    REG_TOOL("crc32","hash","CRC32 checksum","[-o out]",tool_crc32);
    REG_TOOL("adler32","hash","Adler-32 checksum","[-o out]",tool_adler32);
    REG_TOOL("sha256","hash","SHA-256 digest","[-o out]",tool_sha256);
    REG_TOOL("md5_stub","hash","MD5 reference","",tool_md5_stub);
    REG_TOOL("sha1_stub","hash","SHA-1 reference","",tool_sha1_stub);
    REG_TOOL("checksum_file","hash","File CRC32","<file>",tool_checksum_file);
    REG_TOOL("wc","text","Word/line/char count","[-o out]",tool_wc);
    REG_TOOL("trim","text","Trim whitespace","[-o out]",tool_trim);
    REG_TOOL("upper","text","Uppercase","[-o out]",tool_upper);
    REG_TOOL("lower","text","Lowercase","[-o out]",tool_lower);
    REG_TOOL("reverse","text","Reverse string","[-o out]",tool_reverse);
    REG_TOOL("repeat","text","Repeat N times","-n <count> [-o out]",tool_repeat);
    REG_TOOL("lines","text","Count lines","[-o out]",tool_lines);
    REG_TOOL("words","text","Count words","[-o out]",tool_words);
    REG_TOOL("chars","text","Count chars","[-o out]",tool_chars);
    REG_TOOL("replace","text","Find/replace","-f <old> -r <new> [-o out]",tool_replace);
    REG_TOOL("sort","text","Sort lines","[-n] [-o out]",tool_sort);
    REG_TOOL("slugify","text","URL slug","[-o out]",tool_slugify);
    REG_TOOL("truncate","text","Truncate text","-m <max> [-o out]",tool_truncate);
    REG_TOOL("pad_left","text","Pad left","-w <width> [-o out]",tool_pad_left);
    REG_TOOL("pad_right","text","Pad right","-w <width> [-o out]",tool_pad_right);
    REG_TOOL("calc","math","Calculator","<a> <op> <b>",tool_calc);
    REG_TOOL("prime","math","Prime check","<n>",tool_prime);
    REG_TOOL("gcd","math","GCD","<a> <b>",tool_gcd);
    REG_TOOL("lcm","math","LCM","<a> <b>",tool_lcm);
    REG_TOOL("factorial","math","Factorial","<n>",tool_factorial);
    REG_TOOL("fib","math","Fibonacci","<n>",tool_fib);
    REG_TOOL("rand","math","Random int","-min <a> -max <b>",tool_rand);
    REG_TOOL("uuid","dev","UUID v4","",tool_uuid);
    REG_TOOL("timestamp","sys","Unix timestamp","",tool_timestamp);
    REG_TOOL("dateconv","sys","Timestamp to date","<ts>",tool_dateconv);
    REG_TOOL("base_conv","math","Base converter","<val> <in> <out>",tool_base_conv);
    REG_TOOL("color_hex_rgb","dev","Hex to RGB","<#RRGGBB>",tool_color_hex_rgb);
    REG_TOOL("color_rgb_hex","dev","RGB to Hex","<R> <G> <B>",tool_color_rgb_hex);
    REG_TOOL("perm_oct","sys","Octal to perms","<oct>",tool_perm_oct);
    REG_TOOL("bitwise","math","Bitwise ops","<a> <op> <b>",tool_bitwise);
    REG_TOOL("matrix","math","2x2 det","<a> <b> <c> <d>",tool_matrix);
    REG_TOOL("entropy","math","Shannon entropy","[-o out]",tool_entropy);
    REG_TOOL("strength","math","Password strength","[-o out]",tool_strength);
    REG_TOOL("file_hash","file","File CRC32","<file>",tool_file_hash);
    REG_TOOL("file_size","file","File size","<file>",tool_file_size);
    REG_TOOL("file_info","file","File metadata","<file>",tool_file_info);
    REG_TOOL("head","file","First N lines","-n <count> [file]",tool_head);
    REG_TOOL("tail","file","Last N lines","-n <count> [file]",tool_tail);
    REG_TOOL("grep","file","Search pattern","<pattern> [file]",tool_grep);
    REG_TOOL("sed","text","Stream edit","-f <old> -r <new>",tool_sed);
    REG_TOOL("diff","file","Compare files","<f1> <f2>",tool_diff);
    REG_TOOL("touch","file","Update timestamp","<file>",tool_touch);
    REG_TOOL("cat","file","Concatenate","<f1> [f2...]",tool_cat);
    REG_TOOL("ls","sys","List directory","[dir]",tool_ls);
    REG_TOOL("pwd","sys","Working directory","",tool_pwd);
    REG_TOOL("whoami","sys","Current user","",tool_whoami);
    REG_TOOL("hostname","sys","Hostname","",tool_hostname);
    REG_TOOL("uptime","sys","System uptime","",tool_uptime);
    REG_TOOL("env","sys","Environment vars","",tool_env);
    REG_TOOL("pid","sys","Process ID","",tool_pid);
    REG_TOOL("ppid","sys","Parent PID","",tool_ppid);
    REG_TOOL("threads","sys","Thread count","",tool_threads);
    REG_TOOL("json_fmt","format","Pretty JSON","[-o out]",tool_json_fmt);
    REG_TOOL("csv_to_tsv","format","CSV to TSV","[-o out]",tool_csv_to_tsv);
    REG_TOOL("xml_escape","format","XML escape","[-o out]",tool_xml_escape);
    REG_TOOL("markdown_html","format","MD to HTML","[-o out]",tool_markdown_html);
    REG_TOOL("slugify_dev","format","Dev slug","[-o out]",tool_slugify_dev);
    REG_TOOL("template_stub","format","Template engine","",tool_template_stub);
    REG_TOOL("git_hash","dev","Git commit sim","",tool_git_hash);
    REG_TOOL("makefile_gen","dev","Gen Makefile","",tool_makefile_gen);
    REG_TOOL("cmake_gen","dev","Gen CMakeLists","",tool_cmake_gen);
    REG_TOOL("license_gen","dev","Gen MIT License","",tool_license_gen);
    REG_TOOL("readme_gen","dev","Gen README","",tool_readme_gen);
    REG_TOOL("todo_gen","dev","Gen TODO","",tool_todo_gen);
    REG_TOOL("changelog_gen","dev","Gen CHANGELOG","",tool_changelog_gen);
    REG_TOOL("release_notes","dev","Gen release notes","",tool_release_notes);
    REG_TOOL("ping","net","Ping simulation","<host>",tool_ping);
    REG_TOOL("ip_info","net","Local IP info","",tool_ip_info);
    REG_TOOL("dns_lookup","net","DNS resolution","<host>",tool_dns_lookup);
    REG_TOOL("port_scan","net","Port scan sim","<host>",tool_port_scan);
    REG_TOOL("http_get","net","HTTP GET sim","",tool_http_get);
    REG_TOOL("http_post","net","HTTP POST sim","",tool_http_post);
    REG_TOOL("speed_test","net","Network speed","",tool_speed_test);
    REG_TOOL("password_gen","dev","Secure password","",tool_password_gen);
    REG_TOOL("hex_random","dev","Random hex string","<len>",tool_hex_random);
    REG_TOOL("base64_random","dev","Random base64","<len>",tool_base64_random);
    REG_TOOL("ascii_art","dev","Print ASCII logo","",tool_ascii_art);
    REG_TOOL("qr_stub","dev","QR gen stub","",tool_qr_stub);
    REG_TOOL("jwt_encode","dev","JWT encode HS256","",tool_jwt_encode);
    REG_TOOL("jwt_decode","dev","JWT decode sim","",tool_jwt_decode);
    REG_TOOL("ip_to_int","net","IP to integer","<ip>",tool_ip_to_int);
    REG_TOOL("int_to_ip","net","Integer to IP","<int>",tool_int_to_ip);
}

static int dispatch(int argc, char **argv) {
    if (argc < 1) return 0;
    for (int i = 0; i < reg_count; i++) if (strcmp(argv[0], registry[i].name) == 0) return registry[i].execute(argc, argv);
    log_err("Unknown command: %s. Type 'help'.", argv[0]); return 1;
}

/* ======================== REPL SHELL ======================== */
static void run_shell(void) {
    setup_console();
    printf("\033[2J\033[H");
    printf("devtool v%s - Interactive Developer Shell\n", VERSION);
    printf("Type 'help' for commands, 'exit' to quit.\n");
    printf("Supports piping: echo \"data\" | <tool> [flags]\n\n");

    char line[4096];
    while (!g_quit) {
        printf("\033[32mdevtool\033[0m> ");
        fflush(stdout);
        if (!fgets(line, sizeof(line), stdin)) { if (feof(stdin) || ferror(stdin)) break; continue; }
        line[strcspn(line, "\r\n")] = '\0';
        if (!line[0]) continue;
        add_hist(line);

        if (strcmp(line, "exit") == 0 || strcmp(line, "quit") == 0) break;
        if (strcmp(line, "clear") == 0 || strcmp(line, "cls") == 0) { system(CLEAR_CMD); continue; }
        if (strcmp(line, "help") == 0) {
            printf("Core: help, history, clear/cls, exit/quit, version, list [cat]\n");
            printf("Usage: <tool> [args] | echo \"text\" | <tool> -i file.txt -o out.txt\n\n");
            const char *last = "";
            for (int i = 0; i < reg_count; i++) {
                if (strcmp(registry[i].category, last) != 0) { printf("\n[%s]\n", registry[i].category); last = registry[i].category; }
                printf("  %-14s %s\n", registry[i].name, registry[i].description);
            }
            putchar('\n'); continue;
        }
        if (strcmp(line, "history") == 0) { for (int i=0; i<hist_count; i++) printf("  %3d: %s\n", i+1, history[i]); putchar('\n'); continue; }
        if (strncmp(line, "list", 4) == 0) {
            const char *cat = strlen(line) > 4 ? line + 5 : NULL;
            if (cat) { printf("Tools in '%s':\n", cat); for (int i = 0; i < reg_count; i++) if (strcmp(registry[i].category, cat) == 0) printf("  %-14s %s\n", registry[i].name, registry[i].description); }
            else { for (int i = 0; i < reg_count; i++) printf("  %-14s %s\n", registry[i].name, registry[i].description); }
            putchar('\n'); continue;
        }
        if (strcmp(line, "version") == 0) { puts("devtool v" VERSION " | C11 | Zero Dependencies\n"); continue; }

        int cmd_argc = 0; char *cmd_argv[64]; char *token = strtok(line, " ");
        while (token && cmd_argc < 63) { cmd_argv[cmd_argc++] = token; token = strtok(NULL, " "); }
        cmd_argv[cmd_argc] = NULL;
        if (cmd_argc == 0) continue;
        dispatch(cmd_argc, cmd_argv);
        putchar('\n');
    }
    puts("\nGoodbye!");
    for (int i = 0; i < hist_count; i++) free(history[i]);
}

/* ======================== ENTRY POINT ======================== */
int main(int argc, char **argv) {
    register_all();
    if (argc > 1) return dispatch(argc - 1, argv + 1);
    run_shell();
    return 0;
}