@nockdev/awf 6.2.0

package/.agent/skills/languages/nim/data/async.yaml

@@ -0,0 +1,257 @@
+# =============================================================================
+# Nim Async Patterns (Feb 2026)
+# Version: Nim 2.2+
+# =============================================================================
+
+metadata:
+  skill: nim
+  domain: async
+  version: "2.2"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: nim101
+    name: Async/Await
+    category: async
+    version: "Nim"
+    description: |
+      Asynchronous programming with asyncdispatch.
+      Futures, async/await syntax.
+    text: async await future asyncdispatch chronos
+    example: |
+      import asyncdispatch
+
+      # ✅ Async procedure
+      proc fetchData(url: string): Future[string] {.async.} =
+        # Simulated async operation
+        await sleepAsync(100)
+        return "Data from " & url
+
+      # ✅ Await in async context
+      proc processUrls(): Future[seq[string]] {.async.} =
+        var results: seq[string]
+        let urls = @["url1", "url2", "url3"]
+        
+        for url in urls:
+          let data = await fetchData(url)
+          results.add(data)
+        
+        return results
+
+      # ✅ Run async code
+      let results = waitFor processUrls()
+      echo results
+
+      # ✅ Parallel futures
+      proc fetchAll(): Future[seq[string]] {.async.} =
+        let futures = @[
+          fetchData("url1"),
+          fetchData("url2"),
+          fetchData("url3")
+        ]
+        
+        # Wait for all
+        return await all(futures)
+
+      # ✅ Error handling in async
+      proc mightFail(): Future[string] {.async.} =
+        if true:
+          raise newException(IOError, "Network error")
+        return "ok"
+
+      proc handleError(): Future[void] {.async.} =
+        try:
+          let result = await mightFail()
+        except IOError as e:
+          echo "Error: ", e.msg
+
+      # ✅ Chronos (alternative async library)
+      # import chronos
+      # More performance-focused, used in Status projects
+    severity: HIGH
+    docs_url: https://nim-lang.org/docs/asyncdispatch.html
+
+  - id: nim102
+    name: Memory Management
+    category: memory
+    version: "Nim"
+    description: |
+      GC options and manual memory control.
+      ARC, ORC, manual memory.
+    text: gc arc orc memory alloc dealloc
+    example: |
+      # ✅ Compile with different GC
+      # nim c --gc:orc myapp.nim   # Default in Nim 2.0
+      # nim c --gc:arc myapp.nim   # Reference counting
+      # nim c --gc:none myapp.nim  # No GC (manual memory)
+
+      # ✅ Manual memory management
+      type MyObject = object
+        data: ptr UncheckedArray[int]
+        len: int
+
+      proc createObject(size: int): MyObject =
+        result.len = size
+        result.data = cast[ptr UncheckedArray[int]](
+          alloc(size * sizeof(int))
+        )
+
+      proc destroyObject(obj: var MyObject) =
+        if obj.data != nil:
+          dealloc(obj.data)
+          obj.data = nil
+
+      # ✅ Destructor (with ARC/ORC)
+      type Resource = object
+        handle: pointer
+
+      proc `=destroy`(r: Resource) =
+        if r.handle != nil:
+          echo "Cleaning up resource"
+          # cleanup(r.handle)
+
+      proc `=copy`(dest: var Resource, src: Resource) =
+        `=destroy`(dest)
+        dest.handle = src.handle  # Or deep copy
+
+      # ✅ Move semantics
+      proc `=sink`(dest: var Resource, src: Resource) =
+        `=destroy`(dest)
+        dest.handle = src.handle
+
+      # ✅ Disable copy
+      type NoCopy = object
+        data: int
+
+      proc `=copy`(dest: var NoCopy, src: NoCopy) {.error: "NoCopy cannot be copied".}
+
+      # ✅ Weak references (with ORC)
+      # Use {.weak.} pragma for weak references
+    severity: MEDIUM
+    docs_url: https://nim-lang.org/docs/gc.html
+
+  - id: nim103
+    name: C FFI
+    category: ffi
+    version: "Nim"
+    description: |
+      Call C libraries from Nim.
+      Pragmas, wrappers, nimgen.
+    text: ffi c importc dynlib header wrapper
+    example: |
+      # ✅ Import C function
+      proc printf(format: cstring): cint {.importc, varargs, header: "<stdio.h>".}
+
+      discard printf("Hello %s\n", "World")
+
+      # ✅ Import from dynamic library
+      proc SDL_Init(flags: uint32): cint {.importc, dynlib: "libSDL2.so".}
+
+      # ✅ C types mapping
+      type
+        CFile = ptr object  # FILE*
+        size_t = uint       # size_t
+
+      proc fopen(filename, mode: cstring): CFile {.importc, header: "<stdio.h>".}
+      proc fclose(f: CFile): cint {.importc, header: "<stdio.h>".}
+
+      # ✅ C struct
+      type
+        TimeVal {.importc: "struct timeval", header: "<sys/time.h>".} = object
+          tv_sec: clong
+          tv_usec: clong
+
+      # ✅ Callbacks
+      type CCallback = proc(data: pointer, value: cint): cint {.cdecl.}
+
+      proc registerCallback(cb: CCallback, data: pointer) {.importc.}
+
+      proc myCallback(data: pointer, value: cint): cint {.cdecl.} =
+        echo "Callback: ", value
+        return 0
+
+      registerCallback(myCallback, nil)
+
+      # ✅ Export Nim to C
+      proc nimFunction(x: cint): cint {.exportc, cdecl, dynlib.} =
+        return x * 2
+
+      # Compile: nim c --app:lib --noMain mylib.nim
+
+      # ✅ c2nim for automatic wrapping
+      # c2nim header.h > wrapper.nim
+    severity: MEDIUM
+    docs_url: https://nim-lang.org/docs/manual.html#foreign-function-interface
+
+  - id: nim104
+    name: Concurrency
+    category: concurrency
+    version: "Nim"
+    description: |
+      Threads and channels in Nim.
+      Spawn, parallel, shared memory.
+    text: threads spawn parallel channel shared
+    example: |
+      import std/[threadpool, os]
+
+      # ✅ Spawn tasks
+      proc heavyComputation(x: int): int =
+        sleep(100)
+        x * x
+
+      let fut1 = spawn heavyComputation(10)
+      let fut2 = spawn heavyComputation(20)
+
+      sync()  # Wait for all spawned tasks
+
+      echo ^fut1  # Get result: 100
+      echo ^fut2  # Get result: 400
+
+      # ✅ Parallel for
+      import std/threadpool
+
+      var results: array[100, int]
+
+      parallel:
+        for i in 0..99:
+          spawn results[i] = heavyComputation(i)
+
+      # ✅ Channels for communication
+      import std/[channels, threads]
+
+      var chan: Channel[int]
+      chan.open()
+
+      proc producer() {.thread.} =
+        for i in 1..10:
+          chan.send(i)
+          sleep(50)
+
+      proc consumer() {.thread.} =
+        for _ in 1..10:
+          let msg = chan.recv()
+          echo "Received: ", msg
+
+      var t1, t2: Thread[void]
+      createThread(t1, producer)
+      createThread(t2, consumer)
+
+      joinThread(t1)
+      joinThread(t2)
+      chan.close()
+
+      # ✅ Lock for shared data
+      import std/locks
+
+      var lock: Lock
+      var sharedCounter = 0
+
+      lock.initLock()
+
+      proc increment() {.thread.} =
+        for _ in 1..1000:
+          withLock(lock):
+            inc sharedCounter
+    severity: MEDIUM
+    docs_url: https://nim-lang.org/docs/threads.html

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

@@ -0,0 +1,241 @@
+# =============================================================================
+# Nim Core Patterns (Feb 2026)
+# Version: Nim 2.2+
+# =============================================================================
+
+metadata:
+  skill: nim
+  domain: core
+  version: "2.2"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: nim001
+    name: Type System
+    category: types
+    version: "Nim"
+    description: |
+      Nim's powerful type system.
+      Objects, variants, distinct types.
+    text: types object variant distinct enum tuple
+    example: |
+      # ✅ Object types
+      type
+        Person = object
+          name: string
+          age: int
+        
+        # Object with inheritance
+        Animal = object of RootObj
+          name: string
+        
+        Dog = object of Animal
+          breed: string
+
+      # ✅ Variant types (tagged unions)
+      type
+        NodeKind = enum
+          nkInt, nkFloat, nkString
+        
+        Node = object
+          case kind: NodeKind
+          of nkInt: intVal: int
+          of nkFloat: floatVal: float
+          of nkString: strVal: string
+
+      let intNode = Node(kind: nkInt, intVal: 42)
+      let strNode = Node(kind: nkString, strVal: "hello")
+
+      # ✅ Distinct types (type-safe aliases)
+      type
+        Dollars = distinct float
+        Euros = distinct float
+
+      proc `+`(a, b: Dollars): Dollars = Dollars(float(a) + float(b))
+
+      let price = Dollars(10.0)
+      # let mixed = price + Euros(5.0)  # Compile error!
+
+      # ✅ Ref vs value types
+      type
+        RefPerson = ref Person  # Heap allocated
+        ValuePerson = Person    # Stack allocated
+
+      var rp = new(Person)  # Creates RefPerson
+      rp.name = "Alice"
+    severity: HIGH
+    docs_url: https://nim-lang.org/docs/manual.html#types
+
+  - id: nim002
+    name: Macros and Templates
+    category: metaprogramming
+    version: "Nim"
+    description: |
+      Compile-time code generation.
+      Templates, macros, AST manipulation.
+    text: macro template metaprogramming ast compile-time
+    example: |
+      import macros
+
+      # ✅ Templates - compile-time substitution
+      template debug(msg: string, data: untyped) =
+        when defined(debug):
+          echo "[DEBUG] ", msg, ": ", data
+
+      debug("value", 42)  # Expands at compile time
+
+      # ✅ Generic templates
+      template withLock(lock: Lock, body: untyped) =
+        acquire(lock)
+        try:
+          body
+        finally:
+          release(lock)
+
+      withLock(myLock):
+        sharedData += 1
+
+      # ✅ Macros - AST manipulation
+      macro dumpTree(body: untyped): untyped =
+        echo treeRepr(body)
+        result = body
+
+      # ✅ Custom DSL with macros
+      macro html(body: untyped): string =
+        result = newLit("")
+        for node in body:
+          # Build HTML string from DSL
+          discard
+
+      # ✅ Loop unrolling
+      macro unrollFor(count: static[int], body: untyped): untyped =
+        result = newStmtList()
+        for i in 0..<count:
+          result.add(body)
+
+      # ✅ Generate repetitive code
+      macro createAccessors(T: typedesc, fields: varargs[untyped]): untyped =
+        result = newStmtList()
+        for field in fields:
+          let getter = ident("get" & $field)
+          result.add quote do:
+            proc `getter`(self: `T`): auto = self.`field`
+    severity: MEDIUM
+    docs_url: https://nim-lang.org/docs/manual.html#macros
+
+  - id: nim003
+    name: Effects System
+    category: safety
+    version: "Nim"
+    description: |
+      Track side effects at compile time.
+      Pure functions, exceptions, GC safety.
+    text: effects pure noSideEffect raises gcsafe
+    example: |
+      # ✅ Pure functions (no side effects)
+      func add(a, b: int): int {.noSideEffect.} =
+        return a + b
+
+      # 'func' is shorthand for 'proc {.noSideEffect.}'
+      func multiply(a, b: int): int =
+        a * b
+
+      # ✅ Exception tracking
+      proc mightFail() {.raises: [IOError, ValueError].} =
+        raise newException(IOError, "oops")
+
+      proc neverFails() {.raises: [].} =
+        # Cannot raise any exceptions
+        discard
+
+      # ✅ GC safety for threads
+      proc threadSafe(data: ptr int) {.gcsafe.} =
+        # Safe to call from threads
+        data[] += 1
+
+      # ✅ Combined effects
+      proc safeCompute(x: int): int {.noSideEffect, raises: [], gcsafe.} =
+        x * 2
+
+      # ✅ Effect inference
+      proc inferred(x: int): int =
+        # Nim infers this is pure
+        x + 1
+
+      # ✅ Tags for custom effects
+      type DbEffect = object of RootEffect
+
+      proc queryDb(): seq[string] {.tags: [DbEffect].} =
+        @["result"]
+
+      proc pureLogic(): int {.tags: [].} =
+        # Cannot call queryDb here
+        42
+    severity: MEDIUM
+    docs_url: https://nim-lang.org/docs/manual.html#effect-system
+
+  - id: nim004
+    name: Iterators
+    category: iterators
+    version: "Nim"
+    description: |
+      Custom iterators with yield.
+      Inline and closure iterators.
+    text: iterator yield inline closure for loop
+    example: |
+      # ✅ Inline iterator (zero overhead)
+      iterator countUp(a, b: int): int =
+        var i = a
+        while i <= b:
+          yield i
+          inc i
+
+      for i in countUp(1, 10):
+        echo i
+
+      # ✅ Closure iterator (stateful)
+      iterator fibonacci(): int {.closure.} =
+        var a = 0
+        var b = 1
+        while true:
+          yield a
+          let next = a + b
+          a = b
+          b = next
+
+      let fib = fibonacci
+      echo fib()  # 0
+      echo fib()  # 1
+      echo fib()  # 1
+
+      # ✅ Two-phase iteration (items + pairs)
+      type MySeq = object
+        data: seq[int]
+
+      iterator items(s: MySeq): int =
+        for item in s.data:
+          yield item
+
+      iterator pairs(s: MySeq): tuple[key: int, val: int] =
+        for i, item in s.data:
+          yield (i, item)
+
+      let mySeq = MySeq(data: @[10, 20, 30])
+
+      for item in mySeq:
+        echo item
+
+      for i, item in mySeq:
+        echo i, ": ", item
+
+      # ✅ Filter iterator
+      iterator filter[T](s: openArray[T], pred: proc(x: T): bool): T =
+        for item in s:
+          if pred(item):
+            yield item
+
+      for x in filter([1, 2, 3, 4, 5], proc(x: int): bool = x mod 2 == 0):
+        echo x  # 2, 4
+    severity: MEDIUM
+    docs_url: https://nim-lang.org/docs/manual.html#iterators

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

@@ -0,0 +1,13 @@
+name: ocaml
+version: "6.2.0"
+category: functional
+tier: 3
+
+domains:
+  core: 5
+
+desc: "OCaml development patterns for OCaml 5.1+. ML family, algebraic types, pattern matching, multicore."
+
+related_skills:
+  - haskell
+  - fsharp

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

@@ -0,0 +1,123 @@
+---
+name: ocaml
+detect: ["*.ml", "*.mli", "dune", "dune-project", "*.opam"]
+version: "6.1.2"
+category: functional
+tier: 3
+---
+
+# OCaml Patterns — DOMYH Awesome Code
+
+> **Version**: OCaml 5.1+ (2025-2026)
+> **Build**: Dune, opam
+> **Philosophy**: Type-safe, efficient, pragmatic FP
+
+---
+
+## 🎯 When to Use
+
+Use for: Compilers, theorem provers, financial systems, type-safe code.
+**NOT for**: Rapid prototyping, large web ecosystems.
+
+---
+
+## 🔧 Project Setup
+
+```bash
+opam switch create . 5.1.0
+dune init project myapp
+cd myapp
+dune build
+dune exec myapp
+```
+
+### dune file
+
+```lisp
+(executable
+ (name main)
+ (libraries lwt lwt.unix yojson))
+```
+
+---
+
+## 🔄 Core Patterns
+
+### Algebraic Data Types
+
+```ocaml
+type user = {
+  id: int;
+  name: string;
+  email: string;
+}
+
+type result =
+  | Ok of user
+  | NotFound of int
+  | ValidationError of string
+
+let find_user id =
+  match Database.find id with
+  | Some user -> Ok user
+  | None -> NotFound id
+
+let handle_result = function
+  | Ok user -> Printf.printf "Found: %s\n" user.name
+  | NotFound id -> Printf.printf "User %d not found\n" id
+  | ValidationError msg -> Printf.printf "Error: %s\n" msg
+```
+
+### Modules and Functors
+
+```ocaml
+module type STORAGE = sig
+  type key
+  type value
+  val get : key -> value option
+  val set : key -> value -> unit
+end
+
+module MakeCache (S : STORAGE) = struct
+  let cache = Hashtbl.create 100
+
+  let get key =
+    match Hashtbl.find_opt cache key with
+    | Some v -> Some v
+    | None ->
+      match S.get key with
+      | Some v -> Hashtbl.add cache key v; Some v
+      | None -> None
+end
+```
+
+### Async with Lwt
+
+```ocaml
+open Lwt.Syntax
+
+let fetch_user id =
+  let* response = Http.get (Printf.sprintf "/users/%d" id) in
+  let* body = Http.body response in
+  Lwt.return (User.of_json body)
+
+let main () =
+  let* user = fetch_user 1 in
+  print_endline user.name;
+  Lwt.return ()
+
+let () = Lwt_main.run (main ())
+```
+
+---
+
+## ✅ Production Checklist
+
+- [ ] `dune build` passing
+- [ ] Tests with `alcotest`
+- [ ] `ocamlformat` applied
+- [ ] `.mli` interface files
+
+---
+
+_DOMYH Awesome Code • OCaml 5.1+_