chore: wip

Author: chrisbbreuer

packages/zig/src/cli.zig

@@ -33,12 +33,12 @@ pub const CLI = struct {
         return CLI{
             .allocator = allocator,
             .name = try allocator.dupe(u8, name),
-            .commands = std.ArrayList(Command).init(allocator),
+            .commands = .{},
             .global_command = global_cmd,
             .matched_command = null,
             .matched_command_name = null,
             .raw_args = &[_][]const u8{},
-            .args = std.ArrayList([]const u8).init(allocator),
+            .args = .{},
             .options = std.StringHashMap([]const u8).init(allocator),
             .show_help_on_exit = false,
             .show_version_on_exit = false,
@@ -68,7 +68,7 @@ pub const CLI = struct {
     pub fn command(self: *CLI, raw_name: []const u8, description: []const u8, config: types.CommandConfig) !*Command {
         var cmd = try Command.init(self.allocator, raw_name, description, config);
         cmd.cli = @ptrCast(self);
-        try self.commands.append(cmd);
+        try self.commands.append(self.allocator, cmd);
 
         // Return pointer to the command in the ArrayList
         return &self.commands.items[self.commands.items.len - 1];
@@ -139,7 +139,7 @@ pub const CLI = struct {
                     // Copy args (skipping command name)
                     self.args.clearRetainingCapacity();
                     for (parsed.args.items[1..]) |arg| {
-                        try self.args.append(try self.allocator.dupe(u8, arg));
+                        try self.args.append(self.allocator, try self.allocator.dupe(u8, arg));
                     }
 
                     // Copy options
@@ -169,7 +169,7 @@ pub const CLI = struct {
 
             self.args.clearRetainingCapacity();
             for (parsed.args.items) |arg| {
-                try self.args.append(try self.allocator.dupe(u8, arg));
+                try self.args.append(self.allocator, try self.allocator.dupe(u8, arg));
             }
 
             self.options.clearRetainingCapacity();
@@ -211,19 +211,19 @@ pub const CLI = struct {
 
     /// Parse command line arguments
     fn parseArgs(self: *CLI, argv: []const []const u8, cmd: ?*Command) !types.ParsedArgv {
-        var parsed_args = std.ArrayList([]const u8).init(self.allocator);
+        var parsed_args: std.ArrayList([]const u8) = .{};
         var parsed_options = std.StringHashMap([]const u8).init(self.allocator);
 
         // Collect all options (global + command-specific)
-        var all_options = std.ArrayList(*const Option).init(self.allocator);
+        var all_options: std.ArrayList(*const Option) = .{};
         defer all_options.deinit();
 
         for (self.global_command.options.items) |*opt| {
-            try all_options.append(opt);
+            try all_options.append(self.allocator, opt);
         }
         if (cmd) |matched_cmd| {
             for (matched_cmd.options.items) |*opt| {
-                try all_options.append(opt);
+                try all_options.append(self.allocator, opt);
             }
         }
 
@@ -287,7 +287,7 @@ pub const CLI = struct {
                 }
             } else {
                 // Regular argument
-                try parsed_args.append(try self.allocator.dupe(u8, arg));
+                try parsed_args.append(self.allocator, try self.allocator.dupe(u8, arg));
             }
         }
 

packages/zig/src/command.zig

@@ -53,12 +53,12 @@ pub const Command = struct {
             .description = try allocator.dupe(u8, description),
             .name = name,
             .args = args,
-            .options = std.ArrayList(Option).init(allocator),
-            .alias_names = std.ArrayList([]const u8).init(allocator),
+            .options = .{},
+            .alias_names = .{},
             .command_action = null,
             .usage_text = null,
             .version_number = null,
-            .examples = std.ArrayList(types.CommandExample).init(allocator),
+            .examples = .{},
             .help_callback = null,
             .config = config,
             .cli = null,
@@ -125,19 +125,19 @@ pub const Command = struct {
 
     /// Add an example
     pub fn example(self: *Command, ex: types.CommandExample) !void {
-        try self.examples.append(ex);
+        try self.examples.append(self.allocator, ex);
     }
 
     /// Add an option to the command
     pub fn option(self: *Command, raw_name: []const u8, description: []const u8, config: types.OptionConfig) !void {
         const opt = try Option.init(self.allocator, raw_name, description, config);
-        try self.options.append(opt);
+        try self.options.append(self.allocator, opt);
     }
 
     /// Add an alias for the command
     pub fn alias(self: *Command, name: []const u8) !void {
         const alias_copy = try self.allocator.dupe(u8, name);
-        try self.alias_names.append(alias_copy);
+        try self.alias_names.append(self.allocator, alias_copy);
     }
 
     /// Set the action callback

packages/zig/src/completion.zig

@@ -22,8 +22,8 @@ pub fn generateCompletion(allocator: std.mem.Allocator, cli: *const CLI, shell:
 
 /// Generate Bash completion script
 fn generateBash(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8 {
-    var result = std.ArrayList(u8).init(allocator);
-    defer result.deinit();
+    var result: std.ArrayList(u8) = .{};
+    defer result.deinit(allocator);
 
     const writer = result.writer();
 
@@ -65,13 +65,13 @@ fn generateBash(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8 {
     try writer.print("}}\n\n", .{});
     try writer.print("complete -F _{s} {s}\n", .{ cli.name, cli.name });
 
-    return try result.toOwnedSlice();
+    return try result.toOwnedSlice(allocator);
 }
 
 /// Generate Zsh completion script
 fn generateZsh(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8 {
-    var result = std.ArrayList(u8).init(allocator);
-    defer result.deinit();
+    var result: std.ArrayList(u8) = .{};
+    defer result.deinit(allocator);
 
     const writer = result.writer();
 
@@ -109,13 +109,13 @@ fn generateZsh(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8 {
     try writer.print("}}\n\n", .{});
     try writer.print("_{s} \"$@\"\n", .{cli.name});
 
-    return try result.toOwnedSlice();
+    return try result.toOwnedSlice(allocator);
 }
 
 /// Generate Fish completion script
 fn generateFish(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8 {
-    var result = std.ArrayList(u8).init(allocator);
-    defer result.deinit();
+    var result: std.ArrayList(u8) = .{};
+    defer result.deinit(allocator);
 
     const writer = result.writer();
 
@@ -129,13 +129,13 @@ fn generateFish(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8 {
         try writer.print("complete -c {s} -f -a \"{s}\" -d \"{s}\"\n", .{ cli.name, cmd.name, cmd.description });
     }
 
-    return try result.toOwnedSlice();
+    return try result.toOwnedSlice(allocator);
 }
 
 /// Generate PowerShell completion script
 fn generatePowerShell(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8 {
-    var result = std.ArrayList(u8).init(allocator);
-    defer result.deinit();
+    var result: std.ArrayList(u8) = .{};
+    defer result.deinit(allocator);
 
     const writer = result.writer();
 
@@ -151,7 +151,7 @@ fn generatePowerShell(allocator: std.mem.Allocator, cli: *const CLI) ![]const u8
     try writer.print("    $commands | Where-Object {{ $_.CompletionText -like \"$wordToComplete*\" }}\n", .{});
     try writer.print("}}\n", .{});
 
-    return try result.toOwnedSlice();
+    return try result.toOwnedSlice(allocator);
 }
 
 test "bash completion generation" {

packages/zig/src/events.zig

@@ -26,7 +26,7 @@ pub const EventEmitter = struct {
         var iter = self.listeners.iterator();
         while (iter.next()) |entry| {
             self.allocator.free(entry.key_ptr.*);
-            entry.value_ptr.deinit();
+            entry.value_ptr.deinit(self.allocator);
         }
         self.listeners.deinit();
     }
@@ -41,10 +41,10 @@ pub const EventEmitter = struct {
 
         var result = try self.listeners.getOrPut(key);
         if (!result.found_existing) {
-            result.value_ptr.* = std.ArrayList(Listener).init(self.allocator);
+            result.value_ptr.* = .{};
         }
 
-        try result.value_ptr.append(.{
+        try result.value_ptr.append(self.allocator, .{
             .callback = callback,
             .once = false,
         });
@@ -60,10 +60,10 @@ pub const EventEmitter = struct {
 
         var result = try self.listeners.getOrPut(key);
         if (!result.found_existing) {
-            result.value_ptr.* = std.ArrayList(Listener).init(self.allocator);
+            result.value_ptr.* = .{};
         }
 
-        try result.value_ptr.append(.{
+        try result.value_ptr.append(self.allocator, .{
             .callback = callback,
             .once = true,
         });

packages/zig/src/log.zig

@@ -11,8 +11,8 @@ pub const LogOptions = struct {
 
 /// Process markdown-style italic text (_text_)
 fn processMarkdown(allocator: std.mem.Allocator, text: []const u8) ![]const u8 {
-    var result = std.ArrayList(u8).init(allocator);
-    errdefer result.deinit();
+    var result: std.ArrayList(u8) = .{};
+    errdefer result.deinit(allocator);
 
     var i: usize = 0;
     var in_italic = false;
@@ -21,24 +21,24 @@ fn processMarkdown(allocator: std.mem.Allocator, text: []const u8) ![]const u8 {
         if (text[i] == '_' and i + 1 < text.len and text[i + 1] != ' ') {
             // Toggle italic
             if (in_italic) {
-                try result.appendSlice(style.codes.italic.close);
+                try result.appendSlice(allocator, style.codes.italic.close);
             } else {
-                try result.appendSlice(style.codes.italic.open);
+                try result.appendSlice(allocator, style.codes.italic.open);
             }
             in_italic = !in_italic;
             i += 1;
         } else {
-            try result.append(text[i]);
+            try result.append(allocator, text[i]);
             i += 1;
         }
     }
 
     // Close italic if still open
     if (in_italic) {
-        try result.appendSlice(style.codes.italic.close);
+        try result.appendSlice(allocator, style.codes.italic.close);
     }
 
-    return result.toOwnedSlice();
+    return result.toOwnedSlice(allocator);
 }
 
 /// Generic log message with custom symbol and color
@@ -50,11 +50,11 @@ pub fn message(allocator: std.mem.Allocator, text: []const u8, options: LogOptio
 
     const symbol = options.symbol orelse "•";
 
-    var spacing = std.ArrayList(u8).init(allocator);
+    var spacing: std.ArrayList(u8) = .{};
     defer spacing.deinit();
     var i: usize = 0;
     while (i < options.spacing) : (i += 1) {
-        try spacing.append(' ');
+        try spacing.append(allocator, ' ');
     }
 
     if (options.color) |color| {
@@ -138,12 +138,12 @@ pub fn intro(allocator: std.mem.Allocator, text: []const u8) !void {
     const border_len = if (text_len + 4 < term_width) text_len + 4 else term_width;
 
     // Create border
-    var border = std.ArrayList(u8).init(allocator);
+    var border: std.ArrayList(u8) = .{};
     defer border.deinit();
 
     var i: usize = 0;
     while (i < border_len - 2) : (i += 1) {
-        try border.appendSlice(border_char);
+        try border.appendSlice(allocator, border_char);
     }
 
     const border_styled = try style.dim(allocator, border.items);
@@ -177,12 +177,12 @@ pub fn outro(allocator: std.mem.Allocator, text: []const u8) !void {
     const border_len = if (text_len + 4 < term_width) text_len + 4 else term_width;
 
     // Create border
-    var border = std.ArrayList(u8).init(allocator);
+    var border: std.ArrayList(u8) = .{};
     defer border.deinit();
 
     var i: usize = 0;
     while (i < border_len - 2) : (i += 1) {
-        try border.appendSlice(border_char);
+        try border.appendSlice(allocator, border_char);
     }
 
     const border_styled = try style.dim(allocator, border.items);

packages/zig/src/middleware.zig

@@ -56,17 +56,17 @@ pub const MiddlewareChain = struct {
     pub fn init(allocator: std.mem.Allocator) MiddlewareChain {
         return MiddlewareChain{
             .allocator = allocator,
-            .middlewares = std.ArrayList(MiddlewareFn).init(allocator),
+            .middlewares = .{},
         };
     }
 
     pub fn deinit(self: *MiddlewareChain) void {
-        self.middlewares.deinit();
+        self.middlewares.deinit(self.allocator);
     }
 
     /// Add middleware to the chain
     pub fn use(self: *MiddlewareChain, middleware: MiddlewareFn) !void {
-        try self.middlewares.append(middleware);
+        try self.middlewares.append(self.allocator, middleware);
     }
 
     /// Execute all middlewares in order
@@ -123,12 +123,12 @@ pub const RateLimiter = struct {
             .allocator = allocator,
             .max_requests = max_requests,
             .window_ms = window_ms,
-            .requests = std.ArrayList(i64).init(allocator),
+            .requests = .{},
         };
     }
 
     pub fn deinit(self: *RateLimiter) void {
-        self.requests.deinit();
+        self.requests.deinit(self.allocator);
     }
 
     pub fn check(self: *RateLimiter) !bool {
@@ -149,7 +149,7 @@ pub const RateLimiter = struct {
             return false;
         }
 
-        try self.requests.append(now);
+        try self.requests.append(self.allocator, now);
         return true;
     }
 };

packages/zig/src/option.zig

@@ -32,7 +32,7 @@ pub const Option = struct {
             .raw_name = try allocator.dupe(u8, raw_name),
             .description = try allocator.dupe(u8, description),
             .name = undefined,
-            .names = std.ArrayList([]const u8).init(allocator),
+            .names = .{},
             .is_boolean = false,
             .required = null,
             .config = config,
@@ -63,7 +63,7 @@ pub const Option = struct {
             }
 
             const camelcased = try utils.camelcaseOptionName(allocator, trimmed);
-            try opt.names.append(camelcased);
+            try opt.names.append(allocator, camelcased);
         }
 
         // Sort names by length

packages/zig/src/prompts.zig

@@ -217,8 +217,8 @@ pub fn multiSelect(allocator: std.mem.Allocator, options: MultiSelectOptions) ![
         return multiSelect(allocator, options);
     }
 
-    var result = std.ArrayList([]const u8).init(allocator);
-    errdefer result.deinit();
+    var result: std.ArrayList([]const u8) = .{};
+    errdefer result.deinit(allocator);
 
     var iter = std.mem.splitSequence(u8, trimmed, " ");
     while (iter.next()) |num_str| {
@@ -241,7 +241,7 @@ pub fn multiSelect(allocator: std.mem.Allocator, options: MultiSelectOptions) ![
         }
 
         const value = try allocator.dupe(u8, options.options[index - 1].value);
-        try result.append(value);
+        try result.append(allocator, value);
     }
 
     if (result.items.len == 0 and options.required) {
@@ -252,7 +252,7 @@ pub fn multiSelect(allocator: std.mem.Allocator, options: MultiSelectOptions) ![
         return multiSelect(allocator, options);
     }
 
-    return try result.toOwnedSlice();
+    return try result.toOwnedSlice(allocator);
 }
 
 /// Password prompt (masked input)