@nockdev/awf 6.2.6 → 6.2.7

package/.agent/skills/languages/c/SKILL.md

@@ -1,16 +1,16 @@
----
+---
 name: c
 detect: ["*.c", "*.h", "Makefile", "CMakeLists.txt"]
-version: "6.2.6"
+version: "6.2.7"
 category: language
 tier: 1
 ---
 
-# C Language Patterns — DOMYH Awesome Code
+# C Language Patterns DOMYH Awesome Code
 
-> Pure C (ISO C23) development patterns — NOT C++
+> Pure C (ISO C23) development patterns NOT C++
 
-## � Language Identification
+## 🔍 Language Identification
 
 ```yaml
 # C vs C++ distinction (CRITICAL)
@@ -60,7 +60,7 @@ cpp_indicators: # Switch to C++ skill if detected
 
 ---
 
-## 🔧 C23 New Features
+## 🆕 C23 New Features
 
 ### nullptr (replaces NULL)
 
@@ -261,144 +261,16 @@ free(copy);
 
 ---
 
-## 🧠 Memory Management Patterns
-
-### RAII Pattern (Resource Acquisition Is Initialization)
-
-```c
-// ✅ Cleanup attribute (GCC/Clang extension, common in Linux kernel)
-#define AUTO_FREE __attribute__((cleanup(cleanup_free)))
-
-static void cleanup_free(void *p) {
-    free(*(void **)p);
-}
-
-void process_data(void) {
-    AUTO_FREE char *buf = malloc(1024);
-    if (!buf) return;
-
-    // buf automatically freed when function returns
-    // No need for explicit free()
-}
-```
-
-### Error Handling with goto (Linux Kernel Style)
-
-```c
-// ✅ Standard C pattern for resource cleanup
-int process_file(const char *path) {
-    int ret = 0;
-    FILE *fp = NULL;
-    char *buf = NULL;
-
-    fp = fopen(path, "r");
-    if (!fp) {
-        ret = -errno;
-        goto out;
-    }
-
-    buf = malloc(BUFFER_SIZE);
-    if (!buf) {
-        ret = -ENOMEM;
-        goto out_close;
-    }
-
-    // Do processing...
-    if (some_error) {
-        ret = -EINVAL;
-        goto out_free;
-    }
-
-    // Success path
-    ret = 0;
-
-out_free:
-    free(buf);
-out_close:
-    fclose(fp);
-out:
-    return ret;
-}
-```
-
-### Memory Debugging
-
-```bash
-# Valgrind (memory leak detection)
-valgrind --leak-check=full ./program
-
-# AddressSanitizer (compile-time)
-gcc -fsanitize=address -g program.c -o program
-
-# UndefinedBehaviorSanitizer
-gcc -fsanitize=undefined -g program.c -o program
-```
-
----
-
-## 🏗️ Data Structures
+## 📚 Deep-Dive References
 
-### Struct Patterns
+- **Memory Management** — malloc/free patterns, arena allocators, memory pools
+  → See [references/memory-management.md](references/memory-management.md)
 
-```c
-// ✅ Opaque pointer pattern (information hiding)
-// In header file (user.h)
-typedef struct User User;
-User *user_create(const char *name);
-void user_destroy(User *user);
-const char *user_get_name(const User *user);
-
-// In implementation file (user.c)
-struct User {
-    char *name;
-    int id;
-    // Private implementation details
-};
-
-User *user_create(const char *name) {
-    User *u = malloc(sizeof(*u));
-    if (!u) return NULL;
-
-    u->name = strdup(name);
-    if (!u->name) {
-        free(u);
-        return NULL;
-    }
-    u->id = generate_id();
-    return u;
-}
-
-void user_destroy(User *user) {
-    if (user) {
-        free(user->name);
-        free(user);
-    }
-}
-```
+- **Data Structures** — Linked lists, hash maps, ring buffers in C
+  → See [references/data-structures.md](references/data-structures.md)
 
-### Flexible Array Member (FAM)
-
-```c
-// ✅ C99+ pattern for variable-length data
-struct Message {
-    size_t length;
-    uint32_t type;
-    char data[];  // Flexible array member (MUST be last)
-};
-
-struct Message *create_message(const char *text) {
-    size_t len = strlen(text) + 1;
-    struct Message *msg = malloc(sizeof(*msg) + len);
-    if (!msg) return NULL;
-
-    msg->length = len;
-    msg->type = MSG_TYPE_TEXT;
-    memcpy(msg->data, text, len);
-    return msg;
-}
-```
-
----
+- **Platform Headers** — Windows/POSIX specifics, \_REENTRANT, signal handling
+  → See [references/platform-headers.md](references/platform-headers.md)
 
 ## 🔒 Security Best Practices
 
@@ -516,220 +388,6 @@ endif()
 
 ---
 
-## ⚠️ Platform-Specific Headers (CRITICAL)
-
-### Windows Headers Conflicts
-
-> **CRITICAL**: Windows headers have many conflicts. Follow this order exactly!
-
-#### 1. Include Order (winsock2.h BEFORE windows.h)
-
-```c
-// ✅ CORRECT ORDER - winsock2.h MUST come before windows.h
-#define WIN32_LEAN_AND_MEAN  // Exclude rarely-used stuff
-#define NOMINMAX             // Prevent min/max macros (for C++ compat)
-#define STRICT               // Enable strict type checking
-#define UNICODE              // Use Unicode APIs
-#define _UNICODE
-
-#include <winsock2.h>        // 1st - Winsock 2.0
-#include <ws2tcpip.h>        // 2nd - TCP/IP extensions
-#include <windows.h>         // 3rd - Windows API
-
-#pragma comment(lib, "ws2_32.lib")  // Link Winsock library
-
-// ❌ WRONG - causes redefinition errors!
-#include <windows.h>         // includes winsock.h (1.1)
-#include <winsock2.h>        // conflicts with winsock.h!
-```
-
-#### 2. Essential Macros
-
-```c
-// Define BEFORE any Windows includes (in pch.h or first in source)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN  // Excludes: Cryptography, DDE, RPC, Shell, Winsock 1.1
-#endif
-
-#ifndef STRICT
-#define STRICT               // Strict type checking for HANDLE types
-#endif
-
-#include <windows.h>
-```
-
-#### 3. Windows Socket Initialization
-
-```c
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-int init_winsock(void) {
-    WSADATA wsaData;
-    int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
-    if (result != 0) {
-        fprintf(stderr, "WSAStartup failed: %d\n", result);
-        return -1;
-    }
-    return 0;
-}
-
-void cleanup_winsock(void) {
-    WSACleanup();
-}
-```
-
-### Windows Headers Quick Reference
-
-| Header         | Purpose             | Notes                            |
-| -------------- | ------------------- | -------------------------------- |
-| `<windows.h>`  | Core Windows API    | Use with WIN32_LEAN_AND_MEAN     |
-| `<winsock2.h>` | Sockets (Winsock 2) | MUST include BEFORE windows.h    |
-| `<ws2tcpip.h>` | TCP/IP, getaddrinfo | Include after winsock2.h         |
-| `<process.h>`  | Process control     | \_beginthreadex, \_getpid        |
-| `<io.h>`       | Low-level I/O       | \_open, \_read, \_write, \_close |
-| `<direct.h>`   | Directory           | \_mkdir, \_rmdir, \_getcwd       |
-| `<conio.h>`    | Console I/O         | \_getch, \_kbhit                 |
-
----
-
-### Linux/POSIX Headers
-
-#### 1. Feature Test Macros (Define FIRST)
-
-```c
-// Define BEFORE any system headers!
-#define _GNU_SOURCE          // GNU extensions (Linux-specific)
-#define _POSIX_C_SOURCE 200809L  // POSIX.1-2008 compliance
-#define _REENTRANT           // Thread-safe libc functions
-#define _XOPEN_SOURCE 700    // X/Open SUSv4 + POSIX 2008
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <pthread.h>
-```
-
-#### 2. Signal Handling with Threads (Critical)
-
-```c
-#include <pthread.h>
-#include <signal.h>
-#include <stdio.h>
-
-volatile sig_atomic_t shutdown_flag = 0;
-
-// ✅ Block signals in worker threads, handle in dedicated thread
-int main(void) {
-    sigset_t set;
-    sigemptyset(&set);
-    sigaddset(&set, SIGINT);
-    sigaddset(&set, SIGTERM);
-
-    // Block signals in main thread (inherited by child threads)
-    pthread_sigmask(SIG_BLOCK, &set, NULL);
-
-    // Create worker threads (they inherit blocked signals)
-    pthread_t worker;
-    pthread_create(&worker, NULL, worker_func, NULL);
-
-    // Handle signals in main thread with sigwait
-    int sig;
-    while (sigwait(&set, &sig) == 0) {
-        if (sig == SIGINT || sig == SIGTERM) {
-            shutdown_flag = 1;
-            break;
-        }
-    }
-
-    pthread_join(worker, NULL);
-    return 0;
-}
-
-// ❌ AVOID: Signal handlers with threads (race conditions!)
-```
-
-#### 3. Common POSIX Headers
-
-| Header           | Purpose          | Key Functions                       |
-| ---------------- | ---------------- | ----------------------------------- |
-| `<unistd.h>`     | POSIX API        | read, write, close, fork, exec      |
-| `<pthread.h>`    | Threads          | pthread*create, pthread_mutex*\*    |
-| `<signal.h>`     | Signals          | sigaction, sigwait, pthread_sigmask |
-| `<fcntl.h>`      | File control     | open, fcntl, O\_\* flags            |
-| `<sys/types.h>`  | Type definitions | pid_t, size_t, ssize_t              |
-| `<sys/socket.h>` | Sockets          | socket, bind, listen, accept        |
-| `<netinet/in.h>` | Internet addr    | sockaddr_in, htons, ntohs           |
-| `<arpa/inet.h>`  | IP conversion    | inet_pton, inet_ntop                |
-| `<sys/stat.h>`   | File status      | stat, fstat, mkdir                  |
-| `<sys/mman.h>`   | Memory mapping   | mmap, munmap, mprotect              |
-| `<dlfcn.h>`      | Dynamic loading  | dlopen, dlsym, dlclose              |
-| `<errno.h>`      | Error codes      | errno, ENOENT, EINVAL               |
-| `<dirent.h>`     | Directory ops    | opendir, readdir, closedir          |
-
----
-
-### Cross-Platform C Code
-
-```c
-// Platform detection
-#if defined(_WIN32) || defined(_WIN64)
-    #define PLATFORM_WINDOWS 1
-#elif defined(__linux__)
-    #define PLATFORM_LINUX 1
-#elif defined(__APPLE__)
-    #define PLATFORM_MACOS 1
-#else
-    #define PLATFORM_UNIX 1
-#endif
-
-// Platform-specific includes
-#ifdef PLATFORM_WINDOWS
-    #define WIN32_LEAN_AND_MEAN
-    #include <windows.h>
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-    #pragma comment(lib, "ws2_32.lib")
-#else
-    #include <unistd.h>
-    #include <sys/socket.h>
-    #include <netinet/in.h>
-    #include <pthread.h>
-    #include <errno.h>
-#endif
-
-// Cross-platform sleep
-static inline void sleep_ms(unsigned int ms) {
-#ifdef PLATFORM_WINDOWS
-    Sleep(ms);
-#else
-    usleep(ms * 1000);
-#endif
-}
-
-// Cross-platform thread type
-#ifdef PLATFORM_WINDOWS
-    typedef HANDLE thread_t;
-    typedef DWORD thread_ret_t;
-#else
-    typedef pthread_t thread_t;
-    typedef void* thread_ret_t;
-#endif
-
-// Cross-platform socket type
-#ifdef PLATFORM_WINDOWS
-    typedef SOCKET socket_t;
-    #define INVALID_SOCKET_VAL INVALID_SOCKET
-    #define close_socket(s) closesocket(s)
-#else
-    typedef int socket_t;
-    #define INVALID_SOCKET_VAL (-1)
-    #define close_socket(s) close(s)
-#endif
-```
-
----
-
 ## ✅ Production Checklist
 
 - [ ] No memory leaks (Valgrind clean)
@@ -745,4 +403,4 @@ static inline void sleep_ms(unsigned int ms) {
 
 ---
 
-_DOMYH Awesome Code • C Language (ISO C23) • 2025-2026_
+_DOMYH Awesome Code C Language (ISO C23) 2025-2026_

package/.agent/skills/languages/c/references/data-structures.md

@@ -0,0 +1,63 @@
+## 🏗️ Data Structures
+
+### Struct Patterns
+
+```c
+// ✅ Opaque pointer pattern (information hiding)
+// In header file (user.h)
+typedef struct User User;
+User *user_create(const char *name);
+void user_destroy(User *user);
+const char *user_get_name(const User *user);
+
+// In implementation file (user.c)
+struct User {
+    char *name;
+    int id;
+    // Private implementation details
+};
+
+User *user_create(const char *name) {
+    User *u = malloc(sizeof(*u));
+    if (!u) return NULL;
+
+    u->name = strdup(name);
+    if (!u->name) {
+        free(u);
+        return NULL;
+    }
+    u->id = generate_id();
+    return u;
+}
+
+void user_destroy(User *user) {
+    if (user) {
+        free(user->name);
+        free(user);
+    }
+}
+```
+
+### Flexible Array Member (FAM)
+
+```c
+// ✅ C99+ pattern for variable-length data
+struct Message {
+    size_t length;
+    uint32_t type;
+    char data[];  // Flexible array member (MUST be last)
+};
+
+struct Message *create_message(const char *text) {
+    size_t len = strlen(text) + 1;
+    struct Message *msg = malloc(sizeof(*msg) + len);
+    if (!msg) return NULL;
+
+    msg->length = len;
+    msg->type = MSG_TYPE_TEXT;
+    memcpy(msg->data, text, len);
+    return msg;
+}
+```
+
+---

package/.agent/skills/languages/c/references/memory-management.md

@@ -0,0 +1,74 @@
+## 📦  Memory Management Patterns
+
+### RAII Pattern (Resource Acquisition Is Initialization)
+
+```c
+// ✅ Cleanup attribute (GCC/Clang extension, common in Linux kernel)
+#define AUTO_FREE __attribute__((cleanup(cleanup_free)))
+
+static void cleanup_free(void *p) {
+    free(*(void **)p);
+}
+
+void process_data(void) {
+    AUTO_FREE char *buf = malloc(1024);
+    if (!buf) return;
+
+    // buf automatically freed when function returns
+    // No need for explicit free()
+}
+```
+
+### Error Handling with goto (Linux Kernel Style)
+
+```c
+// ✅ Standard C pattern for resource cleanup
+int process_file(const char *path) {
+    int ret = 0;
+    FILE *fp = NULL;
+    char *buf = NULL;
+
+    fp = fopen(path, "r");
+    if (!fp) {
+        ret = -errno;
+        goto out;
+    }
+
+    buf = malloc(BUFFER_SIZE);
+    if (!buf) {
+        ret = -ENOMEM;
+        goto out_close;
+    }
+
+    // Do processing...
+    if (some_error) {
+        ret = -EINVAL;
+        goto out_free;
+    }
+
+    // Success path
+    ret = 0;
+
+out_free:
+    free(buf);
+out_close:
+    fclose(fp);
+out:
+    return ret;
+}
+```
+
+### Memory Debugging
+
+```bash
+# Valgrind (memory leak detection)
+valgrind --leak-check=full ./program
+
+# AddressSanitizer (compile-time)
+gcc -fsanitize=address -g program.c -o program
+
+# UndefinedBehaviorSanitizer
+gcc -fsanitize=undefined -g program.c -o program
+```
+
+---