revert: restore Zig 0.16-dev APIs (will upload dev Zig to pantry)

Reverts the 0.15.1 API downgrade. The repos should target 0.16-dev.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: chrisbbreuer

src/bump.zig

@@ -29,13 +29,6 @@ pub const BumpResult = struct {
     }
 };
 
-fn termSuccess(term: std.process.Child.Term) bool {
-    return switch (term) {
-        .Exited => |code| code == 0,
-        else => false,
-    };
-}
-
 pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
     const config = options.config;
 
@@ -46,12 +39,10 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
             std.debug.print("Warning: You have uncommitted changes.\n", .{});
             if (!config.yes) {
                 std.debug.print("Continue anyway? (y/N): ", .{});
-                const stdin = std.fs.File.stdin();
+                const stdin = std.io.getStdIn().reader();
                 var buf: [10]u8 = undefined;
-                const n = stdin.read(&buf) catch return error.Cancelled;
-                if (n == 0) return error.Cancelled;
-                const input = std.mem.trim(u8, buf[0..n], &std.ascii.whitespace);
-                if (input.len == 0 or (input[0] != 'y' and input[0] != 'Y')) {
+                const input = try stdin.readUntilDelimiterOrEof(&buf, '\n');
+                if (input == null or (input.?.len > 0 and input.?[0] != 'y' and input.?[0] != 'Y')) {
                     return error.Cancelled;
                 }
             }
@@ -127,11 +118,10 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
     // Confirmation prompt
     if (!config.yes and !config.ci) {
         std.debug.print("\nWill update {d} file(s). Continue? (Y/n): ", .{files_to_update.len});
-        const stdin = std.fs.File.stdin();
+        const stdin = std.io.getStdIn().reader();
         var buf: [10]u8 = undefined;
-        const n = stdin.read(&buf) catch return error.Cancelled;
-        if (n > 0) {
-            const inp = std.mem.trim(u8, buf[0..n], &std.ascii.whitespace);
+        const input = try stdin.readUntilDelimiterOrEof(&buf, '\n');
+        if (input) |inp| {
             if (inp.len > 0 and inp[0] != 'y' and inp[0] != 'Y' and inp[0] != '\r') {
                 return error.Cancelled;
             }
@@ -166,12 +156,12 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
     }
 
     // Update all files
-    var updated_files: std.ArrayList([]const u8) = .empty;
+    var updated_files = std.ArrayList([]const u8).init(allocator);
     errdefer {
         for (updated_files.items) |file| {
             allocator.free(file);
         }
-        updated_files.deinit(allocator);
+        updated_files.deinit();
     }
 
     for (files_to_update) |file_path| {
@@ -185,7 +175,7 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
         try file_info.updateVersion(current_version_str, new_version_str);
         try file_info.write();
 
-        try updated_files.append(allocator, try allocator.dupe(u8, file_path));
+        try updated_files.append(try allocator.dupe(u8, file_path));
     }
 
     // Execute custom commands
@@ -203,7 +193,7 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
             defer allocator.free(result.stdout);
             defer allocator.free(result.stderr);
 
-            if (!termSuccess(result.term)) {
+            if (result.term.Exited != 0) {
                 std.debug.print("Command failed: {s}\n", .{result.stderr});
                 return error.CommandFailed;
             }
@@ -290,7 +280,7 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
     return BumpResult{
         .old_version = try allocator.dupe(u8, current_version_str),
         .new_version = try allocator.dupe(u8, new_version_str),
-        .files_updated = try updated_files.toOwnedSlice(allocator),
+        .files_updated = try updated_files.toOwnedSlice(),
         .allocator = allocator,
     };
 }

src/cli.zig

@@ -19,11 +19,11 @@ pub fn parseArgs(allocator: Allocator) !CliArgs {
     defer args.deinit();
 
     var result = CliArgs{};
-    var files: std.ArrayList([]const u8) = .empty;
-    defer files.deinit(allocator);
+    var files = std.ArrayList([]const u8).init(allocator);
+    defer files.deinit();
 
-    var execute_cmds: std.ArrayList([]const u8) = .empty;
-    defer execute_cmds.deinit(allocator);
+    var execute_cmds = std.ArrayList([]const u8).init(allocator);
+    defer execute_cmds.deinit();
 
     // Skip program name
     _ = args.skip();
@@ -175,7 +175,7 @@ pub fn parseArgs(allocator: Allocator) !CliArgs {
 
         if (std.mem.eql(u8, arg, "--execute") or std.mem.eql(u8, arg, "-x")) {
             const value = args.next() orelse return error.MissingValue;
-            try execute_cmds.append(allocator, try allocator.dupe(u8, value));
+            try execute_cmds.append(try allocator.dupe(u8, value));
             continue;
         }
 
@@ -184,7 +184,7 @@ pub fn parseArgs(allocator: Allocator) !CliArgs {
             var file_iter = std.mem.splitScalar(u8, value, ',');
             while (file_iter.next()) |file| {
                 const trimmed = std.mem.trim(u8, file, &std.ascii.whitespace);
-                try files.append(allocator, try allocator.dupe(u8, trimmed));
+                try files.append(try allocator.dupe(u8, trimmed));
             }
             continue;
         }
@@ -195,19 +195,19 @@ pub fn parseArgs(allocator: Allocator) !CliArgs {
                 result.release = try allocator.dupe(u8, arg);
             } else {
                 // Additional positional arguments are files
-                try files.append(allocator, try allocator.dupe(u8, arg));
+                try files.append(try allocator.dupe(u8, arg));
             }
         }
     }
 
     // Set execute commands if any
     if (execute_cmds.items.len > 0) {
-        result.config.execute = try execute_cmds.toOwnedSlice(allocator);
+        result.config.execute = try execute_cmds.toOwnedSlice();
     }
 
     // Set files if any
     if (files.items.len > 0) {
-        result.config.files = try files.toOwnedSlice(allocator);
+        result.config.files = try files.toOwnedSlice();
     }
 
     return result;

src/files.zig

@@ -38,7 +38,7 @@ pub const FileType = enum {
 
     pub fn isTomlFile(self: FileType) bool {
         return self == .cargo_toml or self == .pyproject_toml or
-            self == .ion_toml or self == .generic_toml;
+               self == .ion_toml or self == .generic_toml;
     }
 };
 
@@ -130,17 +130,17 @@ fn updateVersionInJson(allocator: Allocator, content: []const u8, old_version: [
     try obj.put("version", .{ .string = version_str });
 
     // Serialize back to JSON with pretty printing
-    var output: std.ArrayList(u8) = .empty;
-    defer output.deinit(allocator);
+    var output = std.ArrayList(u8).init(allocator);
+    defer output.deinit();
 
     try std.json.stringify(root, .{
         .whitespace = .indent_2,
-    }, output.writer(allocator));
+    }, output.writer());
 
     // Add newline at end
-    try output.append(allocator, '\n');
+    try output.append('\n');
 
-    return try output.toOwnedSlice(allocator);
+    return try output.toOwnedSlice();
 }
 
 fn findVersionInToml(allocator: Allocator, content: []const u8) !?[]u8 {
@@ -174,8 +174,8 @@ fn findVersionInToml(allocator: Allocator, content: []const u8) !?[]u8 {
 fn updateVersionInToml(allocator: Allocator, content: []const u8, old_version: []const u8, new_version: []const u8) ![]u8 {
     _ = old_version;
 
-    var output: std.ArrayList(u8) = .empty;
-    defer output.deinit(allocator);
+    var output = std.ArrayList(u8).init(allocator);
+    defer output.deinit();
 
     var lines = std.mem.splitScalar(u8, content, '\n');
     var line_index: usize = 0;
@@ -186,38 +186,36 @@ fn updateVersionInToml(allocator: Allocator, content: []const u8, old_version: [
         if (std.mem.startsWith(u8, trimmed, "version")) {
             // Check if this is a version field assignment
             const eq_index = std.mem.indexOfScalar(u8, trimmed, '=') orelse {
-                try output.appendSlice(allocator, line);
-                if (lines.rest().len > 0) try output.append(allocator, '\n');
+                try output.appendSlice(line);
+                if (lines.rest().len > 0) try output.append('\n');
                 continue;
             };
 
             const value_part = std.mem.trim(u8, trimmed[eq_index + 1 ..], &std.ascii.whitespace);
             if (value_part.len >= 2 and (value_part[0] == '"' or value_part[0] == '\'')) {
                 // This is a version field, replace it
                 const leading_space = std.mem.indexOfScalar(u8, line, 'v') orelse 0;
-                try output.appendSlice(allocator, line[0..leading_space]);
-                const replacement = try std.fmt.allocPrint(allocator, "version = \"{s}\"", .{new_version});
-                defer allocator.free(replacement);
-                try output.appendSlice(allocator, replacement);
+                try output.appendSlice(line[0..leading_space]);
+                try output.writer().print("version = \"{s}\"", .{new_version});
             } else {
-                try output.appendSlice(allocator, line);
+                try output.appendSlice(line);
             }
         } else {
-            try output.appendSlice(allocator, line);
+            try output.appendSlice(line);
         }
 
-        if (lines.rest().len > 0) try output.append(allocator, '\n');
+        if (lines.rest().len > 0) try output.append('\n');
     }
 
-    return try output.toOwnedSlice(allocator);
+    return try output.toOwnedSlice();
 }
 
 fn findVersionInText(allocator: Allocator, content: []const u8) !?[]u8 {
     // Look for semantic version patterns in text
     // Pattern: \bX.Y.Z\b (word boundaries)
     const semver_pattern = std.mem.indexOf(u8, content, "0.") orelse
-        std.mem.indexOf(u8, content, "1.") orelse
-        return null;
+                           std.mem.indexOf(u8, content, "1.") orelse
+                           return null;
 
     // Extract the version starting from this position
     var end = semver_pattern;
@@ -240,8 +238,8 @@ fn findVersionInText(allocator: Allocator, content: []const u8) !?[]u8 {
 
 fn updateVersionInText(allocator: Allocator, content: []const u8, old_version: []const u8, new_version: []const u8) ![]u8 {
     // Simple find and replace with word boundary consideration
-    var output: std.ArrayList(u8) = .empty;
-    defer output.deinit(allocator);
+    var output = std.ArrayList(u8).init(allocator);
+    defer output.deinit();
 
     var pos: usize = 0;
     while (pos < content.len) {
@@ -258,20 +256,20 @@ fn updateVersionInText(allocator: Allocator, content: []const u8, old_version: [
 
             // Only replace if we have word boundaries on both sides
             if (has_boundary_before and has_boundary_after) {
-                try output.appendSlice(allocator, content[pos..abs_index]);
-                try output.appendSlice(allocator, new_version);
+                try output.appendSlice(content[pos..abs_index]);
+                try output.appendSlice(new_version);
                 pos = end_index;
             } else {
-                try output.appendSlice(allocator, content[pos .. abs_index + 1]);
+                try output.appendSlice(content[pos .. abs_index + 1]);
                 pos = abs_index + 1;
             }
         } else {
-            try output.appendSlice(allocator, remaining);
+            try output.appendSlice(remaining);
             break;
         }
     }
 
-    return try output.toOwnedSlice(allocator);
+    return try output.toOwnedSlice();
 }
 
 fn isVersionChar(c: u8) bool {
@@ -281,12 +279,12 @@ fn isVersionChar(c: u8) bool {
 pub fn findFiles(allocator: Allocator, dir_path: []const u8, recursive: bool, pattern: ?[]const u8) ![][]u8 {
     _ = pattern;
 
-    var files: std.ArrayList([]u8) = .empty;
+    var files = std.ArrayList([]u8).init(allocator);
     errdefer {
         for (files.items) |file| {
             allocator.free(file);
         }
-        files.deinit(allocator);
+        files.deinit();
     }
 
     if (recursive) {
@@ -297,13 +295,13 @@ pub fn findFiles(allocator: Allocator, dir_path: []const u8, recursive: bool, pa
         defer allocator.free(package_json_path);
 
         std.fs.cwd().access(package_json_path, .{}) catch {
-            return files.toOwnedSlice(allocator);
+            return files.toOwnedSlice();
         };
 
-        try files.append(allocator, try allocator.dupe(u8, package_json_path));
+        try files.append(try allocator.dupe(u8, package_json_path));
     }
 
-    return try files.toOwnedSlice(allocator);
+    return try files.toOwnedSlice();
 }
 
 fn findFilesRecursive(allocator: Allocator, files: *std.ArrayList([]u8), dir_path: []const u8) !void {
@@ -334,7 +332,7 @@ fn findFilesRecursive(allocator: Allocator, files: *std.ArrayList([]u8), dir_pat
             .file => {
                 const file_type = FileType.fromPath(entry.name);
                 if (file_type == .package_json or file_type.isTomlFile()) {
-                    try files.append(allocator, try allocator.dupe(u8, full_path));
+                    try files.append(try allocator.dupe(u8, full_path));
                 }
             },
             else => {},