refactor: Zig migration

.agents/skills/discover-zig/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: discover-zig
+description: Automatically discover Zig programming skills when working with Zig. Activates for zig development tasks.
+---
+
+# Zig Skills Discovery
+
+Provides automatic access to comprehensive zig skills.
+
+## When This Skill Activates
+
+This skill auto-activates when you're working with:
+- Zig
+- systems programming
+- comptime
+- allocators
+- C interop
+- build.zig
+- zon package manager
+
+## Available Skills
+
+### Quick Reference
+
+The Zig category contains 6 skills:
+
+1. **zig-build-system**
+2. **zig-c-interop**
+3. **zig-memory-management**
+4. **zig-package-management**
+5. **zig-project-setup**
+6. **zig-testing**
+
+### Load Full Category Details
+
+For complete descriptions and workflows:
+
+```bash
+cat ~/.claude/skills/zig/INDEX.md
+```
+
+This loads the full Zig category index with:
+- Detailed skill descriptions
+- Usage triggers for each skill
+- Common workflow combinations
+- Cross-references to related skills
+
+### Load Specific Skills
+
+Load individual skills as needed:
+
+```bash
+cat ~/.claude/skills/zig/zig-build-system.md
+cat ~/.claude/skills/zig/zig-c-interop.md
+cat ~/.claude/skills/zig/zig-memory-management.md
+```
+
+## Progressive Loading
+
+This gateway skill enables progressive loading:
+- **Level 1**: Gateway loads automatically (you're here now)
+- **Level 2**: Load category INDEX.md for full overview
+- **Level 3**: Load specific skills as needed
+
+## Usage Instructions
+
+1. **Auto-activation**: This skill loads automatically when Claude Code detects zig work
+2. **Browse skills**: Run `cat ~/.claude/skills/zig/INDEX.md` for full category overview
+3. **Load specific skills**: Use bash commands above to load individual skills
+
+---
+
+**Next Steps**: Run `cat ~/.claude/skills/zig/INDEX.md` to see full category details.

.agents/skills/zig-best-practices/C-INTEROP.md

@@ -0,0 +1,89 @@
+# C Interoperability in Zig
+
+Zig can directly import C headers, call C functions, and expose Zig functions to C. Use these patterns when integrating with existing C libraries or system APIs.
+
+## When to Use
+
+- Wrapping C libraries (raylib, SDL, curl)
+- Calling platform-specific system APIs
+- Passing callbacks to C code
+- Writing Zig libraries callable from C
+
+## Importing C Headers
+
+Use `@cImport` to import C headers directly:
+
+```zig
+const ray = @cImport({
+    @cInclude("raylib.h");
+});
+
+pub fn main() void {
+    ray.InitWindow(800, 450, "window title");
+    defer ray.CloseWindow();
+
+    ray.SetTargetFPS(60);
+    while (!ray.WindowShouldClose()) {
+        ray.BeginDrawing();
+        defer ray.EndDrawing();
+        ray.ClearBackground(ray.RAYWHITE);
+    }
+}
+```
+
+Configure include paths in `build.zig`:
+
+```zig
+exe.addIncludePath(.{ .cwd_relative = "/usr/local/include" });
+exe.linkSystemLibrary("raylib");
+```
+
+## Extern Functions (System APIs)
+
+Call platform APIs without bindings using `extern`:
+
+```zig
+const win = @import("std").os.windows;
+
+extern "user32" fn MessageBoxA(
+    ?win.HWND,
+    [*:0]const u8,
+    [*:0]const u8,
+    u32,
+) callconv(.winapi) i32;
+```
+
+## C Callbacks
+
+Pass Zig functions to C libraries using `callconv(.C)`:
+
+```zig
+fn writeCallback(
+    data: *anyopaque,
+    size: c_uint,
+    nmemb: c_uint,
+    user_data: *anyopaque,
+) callconv(.C) c_uint {
+    const buffer: *std.ArrayList(u8) = @alignCast(@ptrCast(user_data));
+    const typed_data: [*]u8 = @ptrCast(data);
+    buffer.appendSlice(typed_data[0 .. nmemb * size]) catch return 0;
+    return nmemb * size;
+}
+```
+
+Key points:
+- `callconv(.C)` makes the function callable from C
+- `*anyopaque` is Zig's equivalent of `void*`
+- Use `@alignCast` and `@ptrCast` to recover typed pointers
+- Return 0 on error (C convention) since Zig errors can't cross FFI boundary
+
+## C Types Mapping
+
+| C Type | Zig Type |
+|--------|----------|
+| `void*` | `*anyopaque` |
+| `char*` | `[*:0]const u8` (null-terminated) |
+| `size_t` | `usize` |
+| `int` | `c_int` |
+| `unsigned int` | `c_uint` |
+| `NULL` | `null` |

.agents/skills/zig-best-practices/DEBUGGING.md

@@ -0,0 +1,70 @@
+# Debugging Memory in Zig
+
+Use GeneralPurposeAllocator (GPA) to detect memory leaks with stack traces showing allocation origins.
+
+## When to Use
+
+- Debugging memory leaks in development
+- Validating cleanup logic in complex systems
+- Investigating use-after-free or double-free bugs
+
+## GeneralPurposeAllocator Pattern
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer std.debug.assert(gpa.deinit() == .ok);
+    const allocator = gpa.allocator();
+
+    // Use allocator for all allocations
+    const data = try allocator.alloc(u8, 1024);
+    defer allocator.free(data);
+
+    // Any leaked allocations will be reported at deinit
+}
+```
+
+## Configuration Options
+
+```zig
+var gpa = std.heap.GeneralPurposeAllocator(.{
+    .stack_trace_depth = 10,  // Stack frames to capture (default: 8)
+    .enable_memory_limit = true,
+    .requested_memory_limit = 1024 * 1024,  // 1MB limit
+}){};
+```
+
+## Leak Report Output
+
+When leaks occur, GPA prints:
+
+```
+error: memory leak detected
+Leak at 0x7f... (1024 bytes)
+    src/main.zig:42:25
+    src/main.zig:38:18
+    ...
+```
+
+## Testing with Leak Detection
+
+`std.testing.allocator` wraps GPA and fails tests on leaks:
+
+```zig
+test "no memory leaks" {
+    const allocator = std.testing.allocator;
+    var list: std.ArrayListUnmanaged(u32) = .empty;
+    defer list.deinit(allocator);
+
+    try list.append(allocator, 42);
+    // Test fails if list.deinit is missing
+}
+```
+
+## Production vs Debug
+
+- Use GPA in debug builds for safety
+- Switch to `std.heap.page_allocator` or arena in release for performance
+- `std.heap.c_allocator` when interfacing heavily with C code

.agents/skills/zig-best-practices/GENERICS.md

@@ -0,0 +1,63 @@
+# Generic Data Structures in Zig
+
+Use comptime type parameters to create reusable generic containers. Return a type from a function to build type-safe collections.
+
+## When to Use
+
+- Implementing custom containers (queues, stacks, trees)
+- Building type-safe wrappers around allocations
+- Creating domain-specific collections
+
+## Pattern: Type-Returning Function
+
+```zig
+pub fn Queue(comptime Child: type) type {
+    return struct {
+        const Self = @This();
+        const Node = struct {
+            data: Child,
+            next: ?*Node,
+        };
+
+        allocator: std.mem.Allocator,
+        start: ?*Node,
+        end: ?*Node,
+
+        pub fn init(allocator: std.mem.Allocator) Self {
+            return Self{ .allocator = allocator, .start = null, .end = null };
+        }
+
+        pub fn enqueue(self: *Self, value: Child) !void {
+            const node = try self.allocator.create(Node);
+            node.* = .{ .data = value, .next = null };
+            if (self.end) |end| end.next = node else self.start = node;
+            self.end = node;
+        }
+
+        pub fn dequeue(self: *Self) ?Child {
+            const start = self.start orelse return null;
+            defer self.allocator.destroy(start);
+            if (start.next) |next| self.start = next else {
+                self.start = null;
+                self.end = null;
+            }
+            return start.data;
+        }
+    };
+}
+```
+
+## Key Techniques
+
+- `@This()` returns the enclosing struct type for self-reference
+- Nested `Node` struct keeps implementation details private
+- Allocator passed to init, stored for later operations
+- `defer` for cleanup in dequeue prevents leaks
+
+## Usage
+
+```zig
+var queue = Queue(u32).init(allocator);
+try queue.enqueue(42);
+const value = queue.dequeue(); // ?u32
+```