@nockdev/awf 6.2.0

package/.agent/skills/languages/c/data/core.yaml

@@ -0,0 +1,179 @@
+# =============================================================================
+# C Core Patterns (Feb 2026)
+# Version: C23/C2x
+# =============================================================================
+
+metadata:
+  skill: c
+  domain: core
+  version: "C23"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: c001
+    name: C23 typeof
+    category: types
+    version: "C23"
+    description: |
+      typeof operator for type inference (C23).
+      Like C++ auto but for C.
+    text: typeof typeof_unqual type inference c23
+    example: |
+      // ✅ C23 typeof - infer type from expression
+      int arr[10];
+      typeof(arr[0]) x = 5;  // x is int
+
+      typeof(arr) ptr;       // ptr is int[10]
+      typeof_unqual(arr) y;  // y is int[10] (removes const/volatile)
+
+      // ✅ Use in macros for type-safe generics
+      #define max(a, b) ({ \
+          typeof(a) _a = (a); \
+          typeof(b) _b = (b); \
+          _a > _b ? _a : _b; \
+      })
+
+      // ✅ Create variables matching another
+      void process(int* data, size_t len) {
+          typeof(*data) sum = 0;  // sum is int
+          for (size_t i = 0; i < len; i++) {
+              sum += data[i];
+          }
+      }
+
+      // ✅ Function pointer type inference
+      int add(int a, int b) { return a + b; }
+      typeof(add)* func_ptr = add;  // Function pointer
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/c/language/typeof
+
+  - id: c002
+    name: C23 constexpr
+    category: constants
+    version: "C23"
+    description: |
+      Compile-time constants with constexpr.
+      Arrays with computed sizes.
+    text: constexpr compile-time constant static
+    example: |
+      // ✅ C23 constexpr - compile-time evaluation
+      constexpr int BUFFER_SIZE = 1024;
+      constexpr int DOUBLE_BUF = BUFFER_SIZE * 2;
+
+      // ✅ Use in array declarations
+      char buffer[BUFFER_SIZE];  // Works at compile time
+
+      // ✅ constexpr with expressions
+      constexpr int fib5 = 5;  // Must be evaluable at compile time
+
+      // ✅ Difference from const
+      const int runtime_val = get_runtime_value();  // Runtime
+      constexpr int compile_val = 42;               // Compile time
+
+      // ❌ Cannot use runtime values
+      // constexpr int bad = runtime_val;  // Error!
+
+      // ✅ Type qualifiers preserved
+      constexpr const char* msg = "Hello";
+
+      // ✅ Static assertions with constexpr
+      static_assert(BUFFER_SIZE >= 512, "Buffer too small");
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/c/language/constexpr
+
+  - id: c003
+    name: C23 nullptr
+    category: pointers
+    version: "C23"
+    description: |
+      Type-safe null pointer constant.
+      Replaces NULL macro issues.
+    text: nullptr null pointer nullptr_t type-safe
+    example: |
+      #include <stddef.h>  // For nullptr_t
+
+      // ✅ C23 nullptr - type-safe null
+      int* ptr = nullptr;  // Clear intent
+
+      // ✅ Why nullptr is better than NULL
+      // NULL is typically defined as ((void*)0) or just 0
+      // This can cause issues with function overloading (in C++)
+      // and varargs
+
+      // ❌ Problem with NULL in varargs
+      void log_ptr(const char* fmt, ...) { /* ... */ }
+      // log_ptr("ptr: %p", NULL);    // May pass as int 0!
+      log_ptr("ptr: %p", nullptr);    // ✅ Correct: passes as pointer
+
+      // ✅ nullptr_t type
+      typedef typeof(nullptr) nullptr_t;  // Or from <stddef.h>
+
+      void accepts_null(nullptr_t n) {
+          // Only accepts nullptr
+      }
+
+      // ✅ Comparison
+      if (ptr == nullptr) {
+          // Handle null case
+      }
+
+      // ✅ In structs
+      struct Node {
+          int value;
+          struct Node* next;
+      };
+
+      struct Node node = { .value = 42, .next = nullptr };
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/c/types/nullptr_t
+
+  - id: c004
+    name: C23 Embed Directive
+    category: preprocessor
+    version: "C23"
+    description: |
+      Embed binary files directly in source.
+      Replacement for xxd/bin2c.
+    text: embed binary include resource file
+    example: |
+      // ✅ C23 #embed - include binary files
+
+      // Embed an image as array
+      static const unsigned char icon[] = {
+          #embed "icon.png"
+      };
+      static const size_t icon_size = sizeof(icon);
+
+      // ✅ With limit parameter
+      static const unsigned char header[] = {
+          #embed "large_file.bin" limit(1024)
+      };
+
+      // ✅ With prefix/suffix
+      static const unsigned char data[] = {
+          #embed "data.bin" prefix(0xAA, 0xBB,) suffix(, 0xCC, 0xDD)
+      };
+
+      // ✅ Conditional embedding
+      #if __has_embed("config.bin")
+          static const unsigned char config[] = {
+              #embed "config.bin"
+          };
+      #else
+          static const unsigned char config[] = {0};
+      #endif
+
+      // ✅ Use embedded data
+      void process_icon(void) {
+          for (size_t i = 0; i < icon_size; i++) {
+              process_byte(icon[i]);
+          }
+      }
+
+      // Benefits over xxd:
+      // - No build step
+      // - Compile-time size known
+      // - Works with any build system
+    severity: HIGH
+    docs_url: https://en.cppreference.com/w/c/preprocessor/embed

package/.agent/skills/languages/c/data/embedded.yaml

@@ -0,0 +1,251 @@
+# =============================================================================
+# C Embedded Patterns (Feb 2026)
+# Version: Embedded / MISRA
+# =============================================================================
+
+metadata:
+  skill: c
+  domain: embedded
+  version: "C23"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: c201
+    name: Volatile for Hardware
+    category: embedded
+    version: "C"
+    description: |
+      volatile keyword for memory-mapped I/O.
+      Prevent optimization of hardware accesses.
+    text: volatile hardware register mmio memory-mapped
+    example: |
+      #include <stdint.h>
+
+      // ✅ Memory-mapped I/O register
+      #define GPIO_BASE   0x40020000
+      #define GPIO_ODR    (*(volatile uint32_t*)(GPIO_BASE + 0x14))
+      #define GPIO_IDR    (*(volatile uint32_t*)(GPIO_BASE + 0x10))
+
+      // Set pin high
+      GPIO_ODR |= (1 << 5);
+
+      // Read pin state
+      uint32_t state = GPIO_IDR & (1 << 5);
+
+      // ✅ Why volatile is required:
+      void wait_for_ready(void) {
+          // Without volatile, compiler may optimize to infinite loop
+          // thinking STATUS never changes
+          volatile uint32_t* status = (volatile uint32_t*)0x40000000;
+          while ((*status & 0x01) == 0) {
+              // Wait for ready bit
+          }
+      }
+
+      // ✅ Struct for register groups
+      typedef struct {
+          volatile uint32_t CR;    // Control
+          volatile uint32_t SR;    // Status
+          volatile uint32_t DR;    // Data
+          volatile uint32_t reserved[5];
+      } UART_TypeDef;
+
+      #define UART1 ((UART_TypeDef*)0x40011000)
+
+      void uart_send(uint8_t byte) {
+          while (!(UART1->SR & (1 << 7)));  // Wait for TXE
+          UART1->DR = byte;
+      }
+
+      // ✅ volatile for ISR-modified variables
+      volatile int isr_flag = 0;
+
+      void interrupt_handler(void) {
+          isr_flag = 1;
+      }
+
+      void main_loop(void) {
+          while (!isr_flag);  // Need volatile or may never exit
+      }
+    severity: HIGH
+    docs_url: https://en.cppreference.com/w/c/language/volatile
+
+  - id: c202
+    name: Bit Fields and Packing
+    category: embedded
+    version: "C"
+    description: |
+      Compact data with bit fields.
+      Memory-efficient structures.
+    text: bitfield packed struct bit manipulation
+    example: |
+      #include <stdint.h>
+
+      // ✅ Bit fields for flags
+      typedef struct {
+          uint8_t enabled : 1;
+          uint8_t mode : 3;       // 0-7
+          uint8_t priority : 2;   // 0-3
+          uint8_t reserved : 2;
+      } DeviceFlags;
+
+      // ✅ Packed struct for protocol
+      #pragma pack(push, 1)
+      typedef struct {
+          uint8_t header;
+          uint16_t length;
+          uint32_t sequence;
+          uint8_t payload[0];  // Flexible array
+      } Packet;
+      #pragma pack(pop)
+      _Static_assert(sizeof(Packet) == 7, "Packet must be 7 bytes");
+
+      // ✅ GCC/Clang attribute syntax
+      typedef struct __attribute__((packed)) {
+          uint8_t type;
+          uint32_t value;
+      } CompactData;
+
+      // ✅ Bit manipulation macros
+      #define BIT(n)           (1UL << (n))
+      #define SET_BIT(x, n)    ((x) |= BIT(n))
+      #define CLEAR_BIT(x, n)  ((x) &= ~BIT(n))
+      #define TOGGLE_BIT(x, n) ((x) ^= BIT(n))
+      #define CHECK_BIT(x, n)  (((x) >> (n)) & 1)
+
+      // ✅ Extract/insert fields
+      #define FIELD_GET(x, mask, shift)  (((x) >> (shift)) & (mask))
+      #define FIELD_SET(x, val, mask, shift) \
+          (((x) & ~((mask) << (shift))) | (((val) & (mask)) << (shift)))
+
+      // Usage
+      uint32_t reg = 0;
+      reg = FIELD_SET(reg, 5, 0x0F, 4);  // Set bits [7:4] to 5
+      int val = FIELD_GET(reg, 0x0F, 4); // Get bits [7:4]
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/c/language/bit_field
+
+  - id: c203
+    name: Interrupt Handling
+    category: embedded
+    version: "C"
+    description: |
+      ISR patterns for embedded systems.
+      Critical sections, atomics.
+    text: interrupt isr critical section atomic nested
+    example: |
+      #include <stdint.h>
+      #include <stdatomic.h>
+
+      // ✅ ISR function (ARM Cortex-M example)
+      void TIM2_IRQHandler(void) __attribute__((interrupt));
+      void TIM2_IRQHandler(void) {
+          // Keep ISRs short!
+          if (TIM2->SR & TIM_SR_UIF) {
+              TIM2->SR &= ~TIM_SR_UIF;  // Clear flag
+              tick_count++;
+          }
+      }
+
+      // ✅ Critical section (disable interrupts)
+      static inline uint32_t enter_critical(void) {
+          uint32_t primask;
+          __asm volatile ("mrs %0, primask" : "=r" (primask));
+          __asm volatile ("cpsid i" ::: "memory");
+          return primask;
+      }
+
+      static inline void exit_critical(uint32_t primask) {
+          __asm volatile ("msr primask, %0" :: "r" (primask) : "memory");
+      }
+
+      // Usage
+      void safe_increment(int* counter) {
+          uint32_t state = enter_critical();
+          (*counter)++;
+          exit_critical(state);
+      }
+
+      // ✅ C11 Atomics (if available)
+      atomic_int shared_counter = 0;
+
+      void isr_with_atomic(void) {
+          atomic_fetch_add(&shared_counter, 1);
+      }
+
+      // ✅ Ring buffer for ISR communication
+      #define RING_SIZE 32
+      volatile uint8_t ring_buffer[RING_SIZE];
+      volatile uint8_t ring_head = 0;
+      volatile uint8_t ring_tail = 0;
+
+      void isr_push(uint8_t byte) {
+          uint8_t next = (ring_head + 1) % RING_SIZE;
+          if (next != ring_tail) {
+              ring_buffer[ring_head] = byte;
+              ring_head = next;
+          }
+      }
+    severity: HIGH
+    docs_url: https://developer.arm.com/documentation/
+
+  - id: c204
+    name: MISRA C Guidelines
+    category: safety
+    version: "MISRA"
+    description: |
+      Safety-critical coding guidelines.
+      Automotive, medical, aerospace.
+    text: misra safety-critical coding guidelines automotive
+    example: |
+      // ✅ MISRA C key rules summary
+
+      // Rule 1.3: No undefined behavior
+      // Always initialize variables
+      int x = 0;  // ✅ Good
+      // int x;   // ❌ Uninitialized
+
+      // Rule 10.1: Use explicit types
+      uint32_t counter = 0U;  // ✅ Use unsigned suffix
+
+      // Rule 11.3: No pointer-to-pointer casts
+      // ❌ int* p = (int*)0x1234;
+      // ✅ Use stdint.h and explicit casts through uintptr_t
+      uintptr_t addr = 0x1234;
+      int* p = (int*)addr;
+
+      // Rule 12.3: Avoid side effects in conditions
+      // ❌ if (x++ > 0) { }
+      // ✅
+      if (x > 0) {
+          x++;
+      }
+
+      // Rule 14.3: Use braces for all control statements
+      if (condition) {
+          do_something();
+      }  // ✅ Even single statements
+
+      // Rule 15.5: Single exit point per function
+      int function(int input) {
+          int result;
+          if (input > 0) {
+              result = input * 2;
+          } else {
+              result = 0;
+          }
+          return result;  // ✅ Single return
+      }
+
+      // Rule 17.7: Return value must be used
+      // ❌ malloc(100);
+      void* ptr = malloc(100);  // ✅ Assigned
+      (void)printf("test");     // ✅ Cast to void if intentionally ignored
+
+      // Rule 20.7: Macro parameters in parentheses
+      #define SQUARE(x) ((x) * (x))  // ✅ Parentheses around x
+
+      // Tools: PC-lint, Polyspace, Parasoft C/C++test, cppcheck --addon=misra
+    severity: HIGH
+    docs_url: https://misra.org.uk/

package/.agent/skills/languages/c/data/memory.yaml

@@ -0,0 +1,253 @@
+# =============================================================================
+# C Memory Patterns (Feb 2026)
+# Version: Modern C with Sanitizers
+# =============================================================================
+
+metadata:
+  skill: c
+  domain: memory
+  version: "C23"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: c101
+    name: Safe malloc Pattern
+    category: memory
+    version: "C"
+    description: |
+      Defensive malloc with NULL checking.
+      Avoid memory leaks and crashes.
+    text: malloc calloc realloc free memory allocation
+    example: |
+      #include <stdlib.h>
+      #include <string.h>
+
+      // ✅ Safe allocation pattern
+      void* safe_malloc(size_t size) {
+          if (size == 0) return NULL;
+          
+          void* ptr = malloc(size);
+          if (!ptr) {
+              // Handle allocation failure
+              perror("malloc failed");
+              exit(EXIT_FAILURE);  // Or return NULL for graceful handling
+          }
+          return ptr;
+      }
+
+      // ✅ calloc for zero-initialized memory
+      int* array = calloc(100, sizeof(int));  // All zeros
+
+      // ✅ Safe realloc pattern (avoid memory leak)
+      int* resize_array(int* arr, size_t new_count) {
+          int* new_arr = realloc(arr, new_count * sizeof(int));
+          if (!new_arr && new_count > 0) {
+              // Original arr is still valid if realloc fails!
+              return arr;  // Keep original on failure
+          }
+          return new_arr;
+      }
+
+      // ✅ Cleanup pattern with goto
+      int process_data(void) {
+          int result = -1;
+          char* buf1 = malloc(1024);
+          char* buf2 = malloc(2048);
+          
+          if (!buf1 || !buf2) goto cleanup;
+          
+          // Do work...
+          result = 0;
+          
+      cleanup:
+          free(buf2);  // free(NULL) is safe
+          free(buf1);
+          return result;
+      }
+
+      // ✅ Set pointer to NULL after free
+      free(ptr);
+      ptr = NULL;  // Avoid dangling pointer
+    severity: HIGH
+    docs_url: https://en.cppreference.com/w/c/memory/malloc
+
+  - id: c102
+    name: Address Sanitizer
+    category: debugging
+    version: "Modern"
+    description: |
+      Compile-time instrumentation for memory bugs.
+      Detect buffer overflows, use-after-free.
+    text: asan sanitizer buffer overflow use-after-free
+    example: |
+      // ✅ Compile with AddressSanitizer
+      // gcc -fsanitize=address -fno-omit-frame-pointer -g main.c
+      // clang -fsanitize=address -fno-omit-frame-pointer -g main.c
+
+      // ✅ Common bugs ASan detects:
+
+      // 1. Buffer overflow
+      void overflow_example(void) {
+          int arr[10];
+          arr[10] = 42;  // ASan: stack-buffer-overflow
+      }
+
+      // 2. Heap buffer overflow
+      void heap_overflow(void) {
+          int* p = malloc(10 * sizeof(int));
+          p[10] = 42;  // ASan: heap-buffer-overflow
+          free(p);
+      }
+
+      // 3. Use after free
+      void use_after_free(void) {
+          int* p = malloc(sizeof(int));
+          free(p);
+          *p = 42;  // ASan: heap-use-after-free
+      }
+
+      // 4. Double free
+      void double_free(void) {
+          int* p = malloc(sizeof(int));
+          free(p);
+          free(p);  // ASan: double-free
+      }
+
+      // 5. Memory leak (with -fsanitize=leak)
+      void leak(void) {
+          int* p = malloc(sizeof(int));
+          // No free - ASan: memory leak
+      }
+
+      // ✅ CMake configuration
+      // set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -fsanitize=address")
+
+      // ✅ Runtime options
+      // ASAN_OPTIONS=detect_leaks=1:halt_on_error=0 ./program
+    severity: HIGH
+    docs_url: https://clang.llvm.org/docs/AddressSanitizer.html
+
+  - id: c103
+    name: Valgrind Patterns
+    category: debugging
+    version: "Modern"
+    description: |
+      Runtime memory analysis with Valgrind.
+      Detect leaks, uninitialized reads.
+    text: valgrind memcheck leak detection memory debugging
+    example: |
+      // ✅ Run with Valgrind
+      // valgrind --leak-check=full --show-leak-kinds=all ./program
+
+      // ✅ Valgrind client requests (optional debugging)
+      #include <valgrind/memcheck.h>
+
+      void custom_allocator(void) {
+          void* pool = malloc(1024);
+          
+          // Tell Valgrind this memory is now "allocated" to user
+          VALGRIND_MALLOCLIKE_BLOCK(pool, 1024, 0, 0);
+          
+          // Mark as uninitialized
+          VALGRIND_MAKE_MEM_UNDEFINED(pool, 1024);
+          
+          // When freed
+          VALGRIND_FREELIKE_BLOCK(pool, 0);
+          free(pool);
+      }
+
+      // ✅ Suppress false positives
+      // Create a suppression file: valgrind --gen-suppressions=all
+
+      // ✅ Common Valgrind output interpretation:
+      // "definitely lost" - Memory you allocated but never freed
+      // "indirectly lost" - Lost because parent pointer was lost
+      // "possibly lost" - Pointer arithmetic hid the pointer
+      // "still reachable" - Not freed but still accessible at exit
+
+      // ✅ Uninitialized value detection
+      void uninit_example(void) {
+          int x;
+          if (x == 0) {  // Valgrind: Conditional jump depends on uninit
+              printf("zero\n");
+          }
+      }
+
+      // ✅ Useful flags
+      // --track-origins=yes   : Show where uninit values came from
+      // --num-callers=20      : More stack frames
+      // --suppressions=file   : Ignore known issues
+    severity: MEDIUM
+    docs_url: https://valgrind.org/docs/manual/mc-manual.html
+
+  - id: c104
+    name: Arena Allocator
+    category: memory
+    version: "Modern"
+    description: |
+      Bulk allocation and deallocation pattern.
+      Fast allocations, single free.
+    text: arena allocator memory pool bump allocator
+    example: |
+      #include <stdlib.h>
+      #include <stdint.h>
+      #include <stdalign.h>
+
+      // ✅ Simple arena allocator
+      typedef struct {
+          uint8_t* base;
+          size_t size;
+          size_t offset;
+      } Arena;
+
+      Arena arena_create(size_t size) {
+          return (Arena){
+              .base = malloc(size),
+              .size = size,
+              .offset = 0
+          };
+      }
+
+      void* arena_alloc(Arena* a, size_t size, size_t align) {
+          // Align the offset
+          size_t aligned = (a->offset + align - 1) & ~(align - 1);
+          
+          if (aligned + size > a->size) {
+              return NULL;  // Out of memory
+          }
+          
+          void* ptr = a->base + aligned;
+          a->offset = aligned + size;
+          return ptr;
+      }
+
+      void arena_reset(Arena* a) {
+          a->offset = 0;  // "Free" all allocations instantly
+      }
+
+      void arena_destroy(Arena* a) {
+          free(a->base);
+          a->base = NULL;
+          a->size = 0;
+          a->offset = 0;
+      }
+
+      // ✅ Usage
+      void process_frame(void) {
+          Arena scratch = arena_create(1024 * 1024);  // 1MB
+          
+          // Allocate freely during frame
+          int* data = arena_alloc(&scratch, 1000 * sizeof(int), alignof(int));
+          char* str = arena_alloc(&scratch, 256, 1);
+          
+          // Do work...
+          
+          // Free everything at once
+          arena_reset(&scratch);
+          
+          // Or destroy when done
+          arena_destroy(&scratch);
+      }
+    severity: MEDIUM
+    docs_url: https://en.wikipedia.org/wiki/Region-based_memory_management

package/.agent/skills/languages/clojure/META.yaml

@@ -0,0 +1,13 @@
+name: clojure
+version: "6.2.0"
+category: functional
+tier: 3
+
+domains:
+  core: 5
+
+desc: "Clojure development patterns for Clojure 1.11+. Lisp on JVM, functional, immutable data, REPL-driven."
+
+related_skills:
+  - java
+  - haskell