@nockdev/awf 6.2.0

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

@@ -0,0 +1,264 @@
+# =============================================================================
+# Lua Core Patterns (Feb 2026)
+# Version: Lua 5.4 / LuaJIT
+# =============================================================================
+
+metadata:
+  skill: lua
+  domain: core
+  version: "5.4"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: lua001
+    name: Tables
+    category: data
+    version: "Lua"
+    description: |
+      Tables as universal data structure.
+      Arrays, dictionaries, objects.
+    text: table array dictionary hash associative
+    example: |
+      -- ✅ Array-style table (1-indexed!)
+      local fruits = {"apple", "banana", "cherry"}
+      print(fruits[1])  -- "apple" (not [0]!)
+
+      for i, fruit in ipairs(fruits) do
+        print(i, fruit)
+      end
+
+      -- ✅ Dictionary-style table
+      local person = {
+        name = "Alice",
+        age = 30,
+        ["full-name"] = "Alice Smith"  -- Keys with special chars
+      }
+
+      print(person.name)
+      print(person["full-name"])
+
+      -- ✅ Mixed table
+      local mixed = {
+        "first",    -- [1] = "first"
+        "second",   -- [2] = "second"
+        key = "value"
+      }
+
+      -- ✅ Iterate all keys
+      for k, v in pairs(person) do
+        print(k, v)
+      end
+
+      -- ✅ Table length
+      print(#fruits)  -- 3 (array portion only)
+
+      -- ✅ Table manipulation
+      table.insert(fruits, "date")
+      table.remove(fruits, 1)
+      table.sort(fruits)
+
+      -- ✅ Copy table (shallow)
+      local function copy(t)
+        local new = {}
+        for k, v in pairs(t) do
+          new[k] = v
+        end
+        return new
+      end
+    severity: HIGH
+    docs_url: https://www.lua.org/manual/5.4/manual.html#3.4.9
+
+  - id: lua002
+    name: Metatables
+    category: oop
+    version: "Lua"
+    description: |
+      Operator overloading and OOP with metatables.
+      __index, __newindex, metamethods.
+    text: metatable metamethod __index operator overloading
+    example: |
+      -- ✅ Basic metatable
+      local Vector = {}
+      Vector.__index = Vector
+
+      function Vector.new(x, y)
+        local self = setmetatable({}, Vector)
+        self.x = x or 0
+        self.y = y or 0
+        return self
+      end
+
+      function Vector:magnitude()
+        return math.sqrt(self.x^2 + self.y^2)
+      end
+
+      -- ✅ Operator overloading
+      function Vector.__add(a, b)
+        return Vector.new(a.x + b.x, a.y + b.y)
+      end
+
+      function Vector.__tostring(v)
+        return string.format("(%g, %g)", v.x, v.y)
+      end
+
+      local v1 = Vector.new(3, 4)
+      local v2 = Vector.new(1, 2)
+      local v3 = v1 + v2
+      print(v3)  -- (4, 6)
+
+      -- ✅ __index for default values
+      local defaults = {timeout = 30, retries = 3}
+      local config = setmetatable({}, {__index = defaults})
+      print(config.timeout)  -- 30 (from defaults)
+
+      -- ✅ __newindex for tracking changes
+      local watched = {}
+      setmetatable(watched, {
+        __newindex = function(t, k, v)
+          print("Setting " .. k .. " to " .. tostring(v))
+          rawset(t, k, v)
+        end
+      })
+      watched.name = "Test"  -- Prints: Setting name to Test
+
+      -- ✅ Common metamethods
+      -- __add, __sub, __mul, __div, __eq, __lt, __le
+      -- __call, __len, __tostring, __gc
+    severity: HIGH
+    docs_url: https://www.lua.org/manual/5.4/manual.html#2.4
+
+  - id: lua003
+    name: Closures
+    category: functional
+    version: "Lua"
+    description: |
+      First-class functions and closures.
+      Upvalues, higher-order functions.
+    text: closure function upvalue lambda callback
+    example: |
+      -- ✅ Basic closure
+      local function makeCounter()
+        local count = 0  -- Upvalue
+        return function()
+          count = count + 1
+          return count
+        end
+      end
+
+      local counter = makeCounter()
+      print(counter())  -- 1
+      print(counter())  -- 2
+
+      -- ✅ Functions as arguments
+      local function map(array, func)
+        local result = {}
+        for i, v in ipairs(array) do
+          result[i] = func(v)
+        end
+        return result
+      end
+
+      local doubled = map({1, 2, 3}, function(x) return x * 2 end)
+
+      -- ✅ Functions as return values
+      local function multiplier(n)
+        return function(x)
+          return x * n
+        end
+      end
+
+      local double = multiplier(2)
+      print(double(5))  -- 10
+
+      -- ✅ Partial application
+      local function partial(func, arg1)
+        return function(...)
+          return func(arg1, ...)
+        end
+      end
+
+      local function greet(greeting, name)
+        return greeting .. ", " .. name
+      end
+
+      local sayHello = partial(greet, "Hello")
+      print(sayHello("World"))  -- "Hello, World"
+
+      -- ✅ Memoization
+      local function memoize(func)
+        local cache = {}
+        return function(arg)
+          if cache[arg] == nil then
+            cache[arg] = func(arg)
+          end
+          return cache[arg]
+        end
+      end
+    severity: MEDIUM
+    docs_url: https://www.lua.org/pil/6.1.html
+
+  - id: lua004
+    name: Coroutines
+    category: concurrency
+    version: "Lua"
+    description: |
+      Cooperative multitasking with coroutines.
+      Yield, resume, producer/consumer.
+    text: coroutine yield resume cooperative async
+    example: |
+      -- ✅ Basic coroutine
+      local co = coroutine.create(function()
+        print("Hello")
+        coroutine.yield()
+        print("World")
+      end)
+
+      coroutine.resume(co)  -- Prints "Hello"
+      coroutine.resume(co)  -- Prints "World"
+
+      -- ✅ Passing values
+      local co = coroutine.create(function(x)
+        while true do
+          x = coroutine.yield(x * 2)
+        end
+      end)
+
+      print(coroutine.resume(co, 10))  -- true, 20
+      print(coroutine.resume(co, 5))   -- true, 10
+
+      -- ✅ Generator pattern
+      local function range(from, to)
+        return coroutine.wrap(function()
+          for i = from, to do
+            coroutine.yield(i)
+          end
+        end)
+      end
+
+      for i in range(1, 5) do
+        print(i)
+      end
+
+      -- ✅ Producer-Consumer
+      local function producer()
+        return coroutine.create(function()
+          while true do
+            local value = io.read()
+            coroutine.yield(value)
+          end
+        end)
+      end
+
+      local function consumer(prod)
+        while true do
+          local status, value = coroutine.resume(prod)
+          if not status then break end
+          print("Consumed:", value)
+        end
+      end
+
+      -- ✅ Coroutine status
+      print(coroutine.status(co))  -- "suspended", "running", "dead"
+    severity: MEDIUM
+    docs_url: https://www.lua.org/manual/5.4/manual.html#2.6

package/.agent/skills/languages/lua/data/embedding.yaml

@@ -0,0 +1,300 @@
+# =============================================================================
+# Lua Embedding Patterns (Feb 2026)
+# Version: Lua 5.4 / LuaJIT
+# =============================================================================
+
+metadata:
+  skill: lua
+  domain: embedding
+  version: "5.4"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: lua101
+    name: C API
+    category: embedding
+    version: "Lua"
+    description: |
+      Embed Lua in C/C++ applications.
+      lua_State, stack operations, calling Lua from C.
+    text: c api embed lua_State stack luaL
+    example: |
+      // ✅ Initialize Lua state
+      #include <lua.h>
+      #include <lauxlib.h>
+      #include <lualib.h>
+
+      int main() {
+          lua_State *L = luaL_newstate();
+          luaL_openlibs(L);  // Standard libraries
+          
+          // ✅ Execute Lua code
+          luaL_dostring(L, "print('Hello from Lua')");
+          
+          // ✅ Load and run file
+          if (luaL_dofile(L, "script.lua") != LUA_OK) {
+              fprintf(stderr, "Error: %s\n", lua_tostring(L, -1));
+          }
+          
+          // ✅ Push/pop stack operations
+          lua_pushnumber(L, 42);
+          lua_pushstring(L, "hello");
+          lua_pushboolean(L, 1);
+          
+          int number = lua_tonumber(L, 1);
+          const char* str = lua_tostring(L, 2);
+          
+          // ✅ Call Lua function from C
+          lua_getglobal(L, "myFunction");
+          lua_pushnumber(L, 10);
+          lua_pushnumber(L, 20);
+          
+          if (lua_pcall(L, 2, 1, 0) != LUA_OK) {
+              // Handle error
+          }
+          
+          double result = lua_tonumber(L, -1);
+          lua_pop(L, 1);
+          
+          // ✅ Register C function to Lua
+          lua_register(L, "cFunction", l_cfunction);
+          // Now callable from Lua as cFunction()
+          
+          lua_close(L);
+          return 0;
+      }
+
+      // ✅ C function callable from Lua
+      static int l_cfunction(lua_State *L) {
+          double x = luaL_checknumber(L, 1);
+          lua_pushnumber(L, x * 2);
+          return 1;  // Number of return values
+      }
+    severity: HIGH
+    docs_url: https://www.lua.org/manual/5.4/manual.html#4
+
+  - id: lua102
+    name: LuaJIT FFI
+    category: ffi
+    version: "LuaJIT"
+    description: |
+      Direct C function calls with LuaJIT FFI.
+      No C wrapper needed, JIT-compiled.
+    text: ffi luajit cdef foreign function interface
+    example: |
+      local ffi = require("ffi")
+
+      -- ✅ Define C types and functions
+      ffi.cdef[[
+        typedef struct { double x, y; } Point;
+        
+        double sqrt(double x);
+        double sin(double x);
+        double cos(double x);
+        
+        int printf(const char* fmt, ...);
+        void* malloc(size_t size);
+        void free(void* ptr);
+      ]]
+
+      -- ✅ Call C functions directly
+      local result = ffi.C.sqrt(16)
+      print(result)  -- 4.0
+
+      ffi.C.printf("Hello %s\n", "FFI")
+
+      -- ✅ Create C structs
+      local point = ffi.new("Point", {x = 3.0, y = 4.0})
+      print(point.x, point.y)
+
+      -- ✅ Arrays
+      local arr = ffi.new("int[10]")
+      for i = 0, 9 do
+        arr[i] = i * 2
+      end
+
+      -- ✅ Pointers
+      local ptr = ffi.new("int[1]")
+      ptr[0] = 42
+
+      -- ✅ Load shared library
+      local lib = ffi.load("mylib")  -- mylib.so or mylib.dll
+      local result = lib.my_function(arg)
+
+      -- ✅ Callbacks
+      local callback = ffi.cast("int (*)(int)", function(x)
+        return x * 2
+      end)
+
+      -- ✅ Memory management
+      local buf = ffi.C.malloc(1024)
+      ffi.gc(buf, ffi.C.free)  -- Auto-free when garbage collected
+
+      -- ✅ String conversion
+      local cstr = ffi.new("char[?]", #"hello" + 1, "hello")
+      local luastr = ffi.string(cstr)
+    severity: HIGH
+    docs_url: https://luajit.org/ext_ffi.html
+
+  - id: lua103
+    name: Game Scripting
+    category: games
+    version: "Lua"
+    description: |
+      Lua patterns for game engines.
+      LÖVE, Defold, Roblox integration.
+    text: love2d defold roblox game engine scripting
+    example: |
+      -- ✅ LÖVE 2D basic structure
+      function love.load()
+        player = {x = 400, y = 300, speed = 200}
+        image = love.graphics.newImage("player.png")
+      end
+
+      function love.update(dt)
+        if love.keyboard.isDown("left") then
+          player.x = player.x - player.speed * dt
+        end
+        if love.keyboard.isDown("right") then
+          player.x = player.x + player.speed * dt
+        end
+      end
+
+      function love.draw()
+        love.graphics.draw(image, player.x, player.y)
+        love.graphics.print("FPS: " .. love.timer.getFPS(), 10, 10)
+      end
+
+      -- ✅ Entity Component System pattern
+      local Entity = {}
+      Entity.__index = Entity
+
+      function Entity.new()
+        return setmetatable({components = {}}, Entity)
+      end
+
+      function Entity:addComponent(name, component)
+        self.components[name] = component
+        return self
+      end
+
+      function Entity:getComponent(name)
+        return self.components[name]
+      end
+
+      -- ✅ State machine for game states
+      local StateMachine = {
+        states = {},
+        current = nil
+      }
+
+      function StateMachine:add(name, state)
+        self.states[name] = state
+      end
+
+      function StateMachine:switch(name)
+        if self.current and self.current.exit then
+          self.current:exit()
+        end
+        self.current = self.states[name]
+        if self.current.enter then
+          self.current:enter()
+        end
+      end
+
+      -- ✅ Object pooling for performance
+      local BulletPool = {
+        available = {},
+        active = {}
+      }
+
+      function BulletPool:get()
+        local bullet = table.remove(self.available) or {x = 0, y = 0}
+        table.insert(self.active, bullet)
+        return bullet
+      end
+
+      function BulletPool:recycle(bullet)
+        for i, b in ipairs(self.active) do
+          if b == bullet then
+            table.remove(self.active, i)
+            table.insert(self.available, bullet)
+            break
+          end
+        end
+      end
+    severity: MEDIUM
+    docs_url: https://love2d.org/wiki/Getting_Started
+
+  - id: lua104
+    name: OpenResty
+    category: web
+    version: "OpenResty"
+    description: |
+      High-performance web apps with OpenResty.
+      Nginx + LuaJIT for web services.
+    text: openresty nginx web server cosocket
+    example: |
+      -- ✅ nginx.conf location block
+      -- location /api {
+      --     content_by_lua_file 'lua/api.lua';
+      -- }
+
+      -- ✅ Basic handler (api.lua)
+      local cjson = require "cjson"
+
+      ngx.header.content_type = "application/json"
+
+      local method = ngx.req.get_method()
+      local uri = ngx.var.uri
+
+      if method == "GET" then
+        ngx.say(cjson.encode({
+          status = "ok",
+          path = uri
+        }))
+      else
+        ngx.status = 405
+        ngx.say(cjson.encode({error = "Method not allowed"}))
+      end
+
+      -- ✅ Read request body
+      ngx.req.read_body()
+      local body = ngx.req.get_body_data()
+      local data = cjson.decode(body)
+
+      -- ✅ Query parameters
+      local args = ngx.req.get_uri_args()
+      local id = args.id
+
+      -- ✅ Non-blocking HTTP request
+      local http = require "resty.http"
+      local httpc = http.new()
+
+      local res, err = httpc:request_uri("http://api.example.com/data", {
+        method = "GET",
+        headers = {["Authorization"] = "Bearer token"}
+      })
+
+      if res then
+        ngx.say(res.body)
+      end
+
+      -- ✅ Redis access
+      local redis = require "resty.redis"
+      local red = redis:new()
+
+      red:connect("127.0.0.1", 6379)
+      red:set("key", "value")
+      local value = red:get("key")
+
+      -- Return connection to pool
+      red:set_keepalive(10000, 100)
+
+      -- ✅ Shared dictionary (cross-worker cache)
+      local shared = ngx.shared.my_cache
+      shared:set("key", "value", 60)  -- 60 seconds TTL
+      local cached = shared:get("key")
+    severity: MEDIUM
+    docs_url: https://openresty.org/en/lua-nginx-module.html

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

@@ -0,0 +1,30 @@
+name: nim
+version: "6.2.0"
+category: systems
+tier: 3
+
+desc: "Nim development patterns for Nim 2.2+. Types, macros, templates, effects, async, ARC/ORC, C FFI."
+
+hsa:
+  enabled: true
+  adapter: nim_adapter.py
+
+triggers:
+  file_patterns:
+    - "*.nim"
+    - "*.nimble"
+    - "nim.cfg"
+  keywords:
+    - nim
+    - nim lang
+    - nimble
+    - nim compile
+  intents:
+    - nim project
+    - compile to c
+    - nim systems
+
+related_skills:
+  - python
+  - rust
+  - zig

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

@@ -0,0 +1,116 @@
+---
+name: nim
+detect: ["*.nim", "*.nimble", "nim.cfg"]
+version: "6.1.2"
+category: systems
+tier: 3
+---
+
+# Nim Patterns — DOMYH Awesome Code
+
+> **Version**: Nim 2.0+ (2025-2026)
+> **Focus**: Python-like syntax, C-like performance
+> **Philosophy**: Efficient, expressive, elegant
+
+---
+
+## 🎯 When to Use
+
+Use for: Systems programming, game dev, CLI tools, scripting with performance.
+**NOT for**: Large team projects (smaller ecosystem), web backends (→ go).
+
+---
+
+## 🔧 Project Setup
+
+```bash
+nimble init myproject
+cd myproject
+nim c -r src/myproject.nim
+```
+
+---
+
+## 🔄 Core Patterns
+
+### Types and Procedures
+
+```nim
+type
+  User = object
+    id: int
+    name: string
+    email: string
+    active: bool
+
+  UserError = object of CatchableError
+
+proc createUser(name, email: string): User =
+  if name.len == 0:
+    raise newException(UserError, "Name required")
+  result = User(id: 1, name: name, email: email, active: true)
+
+proc greet(user: User): string =
+  "Hello, " & user.name & "!"
+
+# Usage
+let user = createUser("John", "john@example.com")
+echo user.greet()
+```
+
+### Templates and Macros
+
+```nim
+# Template (compile-time substitution)
+template time(body: untyped): float =
+  let start = cpuTime()
+  body
+  cpuTime() - start
+
+# Usage
+let elapsed = time:
+  for i in 0..<1_000_000:
+    discard i * 2
+echo "Elapsed: ", elapsed
+
+# Macro (AST manipulation)
+import macros
+
+macro debug(n: varargs[typed]): untyped =
+  result = newNimNode(nnkStmtList)
+  for i in n:
+    result.add quote do:
+      echo astToStr(`i`), " = ", `i`
+
+debug x, y, z  # Prints: x = 1, y = 2, z = 3
+```
+
+### Async/Await
+
+```nim
+import asyncdispatch, httpclient
+
+proc fetchUrl(url: string): Future[string] {.async.} =
+  let client = newAsyncHttpClient()
+  defer: client.close()
+  result = await client.getContent(url)
+
+proc main() {.async.} =
+  let content = await fetchUrl("https://example.com")
+  echo content.len, " bytes"
+
+waitFor main()
+```
+
+---
+
+## ✅ Production Checklist
+
+- [ ] `nim check` passing
+- [ ] Tests with `testament` or `unittest`
+- [ ] `--gc:arc` or `--gc:orc` for memory
+- [ ] Cross-compile for targets
+
+---
+
+_DOMYH Awesome Code • Nim 2.0+_