@nockdev/awf 6.2.0

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

@@ -0,0 +1,304 @@
+# =============================================================================
+# C++ Core Patterns (Feb 2026)
+# Version: C++23/26
+# =============================================================================
+
+metadata:
+  skill: cpp
+  domain: core
+  version: "C++26"
+  updated: "2026-02-05"
+  patterns_count: 5
+
+patterns:
+  - id: cpp001
+    name: Modules (C++20)
+    category: organization
+    version: "C++20"
+    description: |
+      Replace headers with modules for faster builds.
+      Better encapsulation, no include guards.
+    text: modules import export module interface unit
+    example: |
+      // ✅ Module interface unit (math.ixx or math.cppm)
+      export module math;
+
+      export namespace math {
+          int add(int a, int b) { return a + b; }
+          int subtract(int a, int b) { return a - b; }
+          
+          class Calculator {
+          public:
+              int multiply(int a, int b) { return a * b; }
+          };
+      }
+
+      // Internal (not exported)
+      namespace math::detail {
+          void internal_helper() {}
+      }
+
+      // ✅ Module implementation unit
+      module math;
+
+      // Implementation of unexported functions
+      void math::detail::internal_helper() {
+          // Implementation
+      }
+
+      // ✅ Import and use
+      import math;
+      import std;  // Standard library module (C++23)
+
+      int main() {
+          std::println("{}", math::add(2, 3));
+          math::Calculator calc;
+          std::println("{}", calc.multiply(4, 5));
+      }
+
+      // ✅ CMake support
+      // CMakeLists.txt:
+      // add_library(math)
+      // target_sources(math PUBLIC FILE_SET CXX_MODULES FILES math.cppm)
+    severity: HIGH
+    docs_url: https://en.cppreference.com/w/cpp/language/modules
+
+  - id: cpp002
+    name: Concepts (C++20)
+    category: templates
+    version: "C++20"
+    description: |
+      Constrain templates with readable requirements.
+      Better error messages, clearer intent.
+    text: concepts requires template constraint auto
+    example: |
+      #include <concepts>
+      #include <ranges>
+
+      // ✅ Define a concept
+      template<typename T>
+      concept Numeric = std::integral<T> || std::floating_point<T>;
+
+      template<typename T>
+      concept Hashable = requires(T t) {
+          { std::hash<T>{}(t) } -> std::convertible_to<std::size_t>;
+      };
+
+      // ✅ Use concept as constraint
+      template<Numeric T>
+      T add(T a, T b) { return a + b; }
+
+      // ✅ Use with requires clause
+      template<typename T>
+      requires Numeric<T>
+      T multiply(T a, T b) { return a * b; }
+
+      // ✅ Inline requires
+      template<typename T>
+      requires std::integral<T> && (sizeof(T) >= 4)
+      void process_large_int(T value) {}
+
+      // ✅ Abbreviated function template
+      void print(const std::ranges::range auto& r) {
+          for (const auto& item : r) {
+              std::println("{}", item);
+          }
+      }
+
+      // ✅ Constrained auto
+      Numeric auto calculate(Numeric auto x, Numeric auto y) {
+          return x * y + x;
+      }
+
+      // ✅ Standard library concepts
+      // std::same_as, std::derived_from, std::convertible_to
+      // std::integral, std::floating_point
+      // std::copyable, std::movable, std::regular
+      // std::invocable, std::predicate
+      // std::ranges::range, std::ranges::input_range
+    severity: HIGH
+    docs_url: https://en.cppreference.com/w/cpp/concepts
+
+  - id: cpp003
+    name: std::expected (C++23)
+    category: error-handling
+    version: "C++23"
+    description: |
+      Type-safe error handling without exceptions.
+      Similar to Rust Result type.
+    text: expected error handling result optional monadic
+    example: |
+      #include <expected>
+      #include <string>
+      #include <fstream>
+
+      // ✅ Define error type
+      enum class FileError {
+          NotFound,
+          PermissionDenied,
+          InvalidFormat
+      };
+
+      // ✅ Return expected instead of throw
+      std::expected<std::string, FileError> read_file(const std::string& path) {
+          std::ifstream file(path);
+          if (!file) {
+              return std::unexpected(FileError::NotFound);
+          }
+          
+          std::string content((std::istreambuf_iterator<char>(file)),
+                               std::istreambuf_iterator<char>());
+          return content;
+      }
+
+      // ✅ Check and use
+      void process() {
+          auto result = read_file("config.json");
+          
+          if (result) {
+              std::println("Content: {}", *result);
+          } else {
+              switch (result.error()) {
+                  case FileError::NotFound:
+                      std::println("File not found");
+                      break;
+                  case FileError::PermissionDenied:
+                      std::println("Permission denied");
+                      break;
+              }
+          }
+      }
+
+      // ✅ Monadic operations (C++23)
+      auto process_file(const std::string& path) {
+          return read_file(path)
+              .transform([](const std::string& s) {
+                  return parse_json(s);
+              })
+              .transform_error([](FileError e) {
+                  return map_to_app_error(e);
+              });
+      }
+
+      // ✅ value_or for defaults
+      std::string content = read_file("config.json").value_or("{}");
+    severity: HIGH
+    docs_url: https://en.cppreference.com/w/cpp/utility/expected
+
+  - id: cpp004
+    name: Deducing this (C++23)
+    category: language
+    version: "C++23"
+    description: |
+      Explicit object parameter for member functions.
+      CRTP without templates, perfect forwarding this.
+    text: deducing this explicit object parameter self
+    example: |
+      #include <type_traits>
+
+      // ✅ Basic syntax - explicit object parameter
+      struct Container {
+          std::vector<int> data;
+          
+          // Single implementation for const and non-const
+          template<typename Self>
+          auto&& get(this Self&& self, size_t index) {
+              return std::forward<Self>(self).data[index];
+          }
+          
+          // Works for const and non-const access
+      };
+
+      Container c{{1, 2, 3}};
+      c.get(0) = 10;  // Non-const, modifiable
+
+      const Container& cc = c;
+      auto val = cc.get(0);  // Const access
+
+      // ✅ Replace CRTP with deducing this
+      struct Comparisons {
+          template<typename Self>
+          bool operator!=(this const Self& self, const Self& other) {
+              return !(self == other);
+          }
+          
+          template<typename Self>
+          bool operator<=(this const Self& self, const Self& other) {
+              return !(other < self);
+          }
+      };
+
+      struct Point : Comparisons {
+          int x, y;
+          bool operator==(const Point&) const = default;
+          bool operator<(const Point& other) const {
+              return std::tie(x, y) < std::tie(other.x, other.y);
+          }
+      };
+
+      // ✅ Recursive lambdas
+      auto factorial = [](this auto self, int n) -> int {
+          return n <= 1 ? 1 : n * self(n - 1);
+      };
+
+      int result = factorial(5);  // 120
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/cpp/language/member_functions#Explicit_object_parameter
+
+  - id: cpp005
+    name: if consteval (C++23)
+    category: metaprogramming
+    version: "C++23"
+    description: |
+      Compile-time vs runtime code selection.
+      Supersedes is_constant_evaluated.
+    text: consteval constexpr if compile-time constant
+    example: |
+      #include <cmath>
+
+      // ✅ if consteval - compile-time branch selection
+      constexpr double power(double base, int exp) {
+          if consteval {
+              // Compile-time: use simple loop
+              double result = 1.0;
+              for (int i = 0; i < exp; ++i) {
+                  result *= base;
+              }
+              return result;
+          } else {
+              // Runtime: use optimized std::pow
+              return std::pow(base, exp);
+          }
+      }
+
+      // Compile-time usage
+      constexpr double compile_result = power(2.0, 10);  // Uses loop
+
+      // Runtime usage
+      double runtime_result = power(2.0, 10);  // Uses std::pow
+
+      // ✅ Difference from if constexpr
+      // if constexpr: branch on compile-time boolean
+      // if consteval: branch on whether in constant evaluation
+
+      // ✅ Use with constexpr functions that have runtime fallback
+      constexpr int compute(int x) {
+          if consteval {
+              // No UB checks in constexpr context
+              return x * 2;
+          } else {
+              // Can use runtime-only features
+              [[assume(x > 0)]];  // Runtime hint
+              return x * 2;
+          }
+      }
+
+      // ✅ Negated form
+      constexpr void debug_only(const char* msg) {
+          if !consteval {
+              // Only runs at runtime
+              std::println("Debug: {}", msg);
+          }
+      }
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/cpp/language/if#Consteval_if

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

@@ -0,0 +1,247 @@
+# =============================================================================
+# C++ Memory Patterns (Feb 2026)
+# Version: C++20/23/26
+# =============================================================================
+
+metadata:
+  skill: cpp
+  domain: memory
+  version: "C++26"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: cpp201
+    name: std::span (C++20)
+    category: memory
+    version: "C++20"
+    description: |
+      Non-owning view over contiguous memory.
+      Replace raw pointer + size parameters.
+    text: span view array vector contiguous memory
+    example: |
+      #include <span>
+      #include <vector>
+      #include <array>
+
+      // ✅ Accept any contiguous container
+      void process(std::span<const int> data) {
+          for (int value : data) {
+              std::println("{}", value);
+          }
+      }
+
+      // Works with:
+      std::vector<int> vec = {1, 2, 3};
+      std::array<int, 3> arr = {4, 5, 6};
+      int c_arr[] = {7, 8, 9};
+
+      process(vec);
+      process(arr);
+      process(c_arr);
+
+      // ✅ Subspan operations
+      std::span<int> data(vec);
+      auto first_two = data.first(2);
+      auto last_two = data.last(2);
+      auto middle = data.subspan(1, 2);
+
+      // ✅ Fixed-extent span
+      std::span<int, 3> fixed(arr);  // Compile-time size known
+
+      // ✅ Mutable vs const
+      void modify(std::span<int> data) {
+          for (int& v : data) v *= 2;
+      }
+
+      void read_only(std::span<const int> data) {
+          // Cannot modify
+      }
+
+      // ✅ Span from string_view (C++20)
+      void process_bytes(std::span<const std::byte> bytes) {
+          // Binary data processing
+      }
+
+      // ✅ Multi-dimensional with mdspan (C++23)
+      // See mdspan pattern below
+    severity: HIGH
+    docs_url: https://en.cppreference.com/w/cpp/container/span
+
+  - id: cpp202
+    name: std::mdspan (C++23)
+    category: memory
+    version: "C++23"
+    description: |
+      Multi-dimensional view over contiguous memory.
+      Matrix operations, scientific computing.
+    text: mdspan multidimensional matrix array view
+    example: |
+      #include <mdspan>
+      #include <vector>
+
+      // ✅ 2D view over flat array
+      std::vector<int> data(12);  // 3x4 matrix
+      std::mdspan matrix(data.data(), 3, 4);
+
+      // Access elements
+      matrix[1, 2] = 42;  // C++23 multidimensional subscript
+
+      // ✅ Iterate over matrix
+      for (size_t i = 0; i < matrix.extent(0); ++i) {
+          for (size_t j = 0; j < matrix.extent(1); ++j) {
+              std::print("{} ", matrix[i, j]);
+          }
+          std::println();
+      }
+
+      // ✅ Layout policies
+      using RowMajor = std::mdspan<int, std::dextents<size_t, 2>, std::layout_right>;
+      using ColMajor = std::mdspan<int, std::dextents<size_t, 2>, std::layout_left>;
+
+      RowMajor row_matrix(data.data(), 3, 4);  // C-style
+      // ColMajor col_matrix(data.data(), 3, 4);  // Fortran-style
+
+      // ✅ Static extents for optimization
+      using Matrix3x3 = std::mdspan<float, std::extents<size_t, 3, 3>>;
+
+      std::array<float, 9> mat_data{};
+      Matrix3x3 mat(mat_data.data());
+
+      // ✅ Mixed static/dynamic extents
+      using DynamicRows = std::mdspan<int, std::extents<size_t, std::dynamic_extent, 4>>;
+
+      // ✅ Submdspan (C++26)
+      auto submatrix = std::submdspan(matrix, 
+          std::pair{0, 2},   // Rows 0-1
+          std::pair{1, 3});  // Cols 1-2
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/cpp/container/mdspan
+
+  - id: cpp203
+    name: Memory Alignment
+    category: memory
+    version: "C++11+"
+    description: |
+      Control memory alignment for performance.
+      SIMD, cache optimization.
+    text: alignas alignof alignment cache line simd
+    example: |
+      #include <new>
+      #include <memory>
+
+      // ✅ alignas - specify alignment
+      struct alignas(64) CacheAligned {
+          int data[16];  // Fits in one cache line
+      };
+
+      // ✅ alignof - query alignment
+      static_assert(alignof(CacheAligned) == 64);
+
+      // ✅ SIMD alignment
+      struct alignas(32) SimdData {
+          float values[8];  // AVX-aligned
+      };
+
+      // ✅ Aligned allocation (C++17)
+      struct alignas(128) LargeAligned {
+          char data[256];
+      };
+
+      // Stack allocation respects alignas
+      LargeAligned stack_obj;
+
+      // Heap allocation (C++17 aligned new)
+      auto* heap_obj = new LargeAligned;
+
+      // ✅ Over-aligned types with smart pointers
+      auto ptr = std::make_unique<alignas(64) float[]>(100);
+
+      // ✅ aligned_alloc for raw memory
+      void* raw = std::aligned_alloc(64, 1024);
+      std::free(raw);
+
+      // ✅ Check alignment at runtime
+      bool is_aligned = (reinterpret_cast<uintptr_t>(ptr.get()) % 64) == 0;
+
+      // ✅ [[assume]] for optimization hints (C++23)
+      void process(float* data) {
+          [[assume(reinterpret_cast<uintptr_t>(data) % 32 == 0)]];
+          // Compiler can assume data is 32-byte aligned
+      }
+
+      // ✅ Hardware constructive/destructive interference
+      struct alignas(std::hardware_destructive_interference_size) ThreadLocalCounter {
+          std::atomic<int> count{0};
+      };
+      // Prevents false sharing between threads
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/cpp/language/alignas
+
+  - id: cpp204
+    name: Custom Allocators
+    category: memory
+    version: "C++11+"
+    description: |
+      Control memory allocation strategy.
+      Pool allocators, arena allocators.
+    text: allocator pmr polymorphic memory resource pool
+    example: |
+      #include <memory_resource>
+      #include <vector>
+
+      // ✅ Stack-based allocation (pmr)
+      std::array<std::byte, 10000> buffer;
+      std::pmr::monotonic_buffer_resource pool(
+          buffer.data(), buffer.size()
+      );
+
+      std::pmr::vector<int> vec(&pool);
+      vec.push_back(1);  // Allocates from buffer, not heap
+
+      // ✅ Pool resource for many small objects
+      std::pmr::synchronized_pool_resource sync_pool;
+      std::pmr::vector<std::string> strings(&sync_pool);
+
+      // ✅ Unsynchronized for single-threaded
+      std::pmr::unsynchronized_pool_resource fast_pool;
+      std::pmr::vector<int> local_vec(&fast_pool);
+
+      // ✅ Custom allocator (classic style)
+      template<typename T>
+      class PoolAllocator {
+          MemoryPool* pool_;
+          
+      public:
+          using value_type = T;
+          
+          explicit PoolAllocator(MemoryPool* p) : pool_(p) {}
+          
+          T* allocate(size_t n) {
+              return static_cast<T*>(pool_->allocate(n * sizeof(T), alignof(T)));
+          }
+          
+          void deallocate(T* p, size_t n) {
+              pool_->deallocate(p, n * sizeof(T));
+          }
+      };
+
+      // ✅ Arena allocator pattern
+      class ArenaAllocator {
+          std::vector<std::byte> buffer_;
+          size_t offset_ = 0;
+          
+      public:
+          explicit ArenaAllocator(size_t size) : buffer_(size) {}
+          
+          void* allocate(size_t size, size_t align) {
+              offset_ = (offset_ + align - 1) & ~(align - 1);
+              auto* ptr = buffer_.data() + offset_;
+              offset_ += size;
+              return ptr;
+          }
+          
+          void reset() { offset_ = 0; }  // Free all at once
+      };
+    severity: MEDIUM
+    docs_url: https://en.cppreference.com/w/cpp/memory/memory_resource