fix: correct Zig 0.15.1 API usage (PascalCase Term, unmanaged ArrayList)

Use std.fs.File.stdin() instead of std.io.getStdIn(), PascalCase
.Exited/.Signal for Child.Term, and unmanaged ArrayList (.empty +
allocator params) throughout all source files.

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

Author: chrisbbreuer

src/bump.zig

@@ -29,6 +29,13 @@ 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;
 
@@ -39,10 +46,12 @@ 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.io.getStdIn().reader();
+                const stdin = std.fs.File.stdin();
                 var buf: [10]u8 = undefined;
-                const input = try stdin.readUntilDelimiterOrEof(&buf, '\n');
-                if (input == null or (input.?.len > 0 and input.?[0] != 'y' and input.?[0] != 'Y')) {
+                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')) {
                     return error.Cancelled;
                 }
             }
@@ -118,10 +127,11 @@ 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.io.getStdIn().reader();
+        const stdin = std.fs.File.stdin();
         var buf: [10]u8 = undefined;
-        const input = try stdin.readUntilDelimiterOrEof(&buf, '\n');
-        if (input) |inp| {
+        const n = stdin.read(&buf) catch return error.Cancelled;
+        if (n > 0) {
+            const inp = std.mem.trim(u8, buf[0..n], &std.ascii.whitespace);
             if (inp.len > 0 and inp[0] != 'y' and inp[0] != 'Y' and inp[0] != '\r') {
                 return error.Cancelled;
             }
@@ -156,12 +166,12 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
     }
 
     // Update all files
-    var updated_files = std.ArrayList([]const u8).init(allocator);
+    var updated_files: std.ArrayList([]const u8) = .empty;
     errdefer {
         for (updated_files.items) |file| {
             allocator.free(file);
         }
-        updated_files.deinit();
+        updated_files.deinit(allocator);
     }
 
     for (files_to_update) |file_path| {
@@ -175,7 +185,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(try allocator.dupe(u8, file_path));
+        try updated_files.append(allocator, try allocator.dupe(u8, file_path));
     }
 
     // Execute custom commands
@@ -193,7 +203,7 @@ pub fn versionBump(allocator: Allocator, options: BumpOptions) !BumpResult {
             defer allocator.free(result.stdout);
             defer allocator.free(result.stderr);
 
-            if (result.term.Exited != 0) {
+            if (!termSuccess(result.term)) {
                 std.debug.print("Command failed: {s}\n", .{result.stderr});
                 return error.CommandFailed;
             }
@@ -280,7 +290,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(),
+        .files_updated = try updated_files.toOwnedSlice(allocator),
         .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).init(allocator);
-    defer files.deinit();
+    var files: std.ArrayList([]const u8) = .empty;
+    defer files.deinit(allocator);
 
-    var execute_cmds = std.ArrayList([]const u8).init(allocator);
-    defer execute_cmds.deinit();
+    var execute_cmds: std.ArrayList([]const u8) = .empty;
+    defer execute_cmds.deinit(allocator);
 
     // 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(try allocator.dupe(u8, value));
+            try execute_cmds.append(allocator, 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(try allocator.dupe(u8, trimmed));
+                try files.append(allocator, 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(try allocator.dupe(u8, arg));
+                try files.append(allocator, try allocator.dupe(u8, arg));
             }
         }
     }
 
     // Set execute commands if any
     if (execute_cmds.items.len > 0) {
-        result.config.execute = try execute_cmds.toOwnedSlice();
+        result.config.execute = try execute_cmds.toOwnedSlice(allocator);
     }
 
     // Set files if any
     if (files.items.len > 0) {
-        result.config.files = try files.toOwnedSlice();
+        result.config.files = try files.toOwnedSlice(allocator);
     }
 
     return result;

src/files.zig

@@ -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).init(allocator);
-    defer output.deinit();
+    var output: std.ArrayList(u8) = .empty;
+    defer output.deinit(allocator);
 
     try std.json.stringify(root, .{
         .whitespace = .indent_2,
-    }, output.writer());
+    }, output.writer(allocator));
 
     // Add newline at end
-    try output.append('\n');
+    try output.append(allocator, '\n');
 
-    return try output.toOwnedSlice();
+    return try output.toOwnedSlice(allocator);
 }
 
 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).init(allocator);
-    defer output.deinit();
+    var output: std.ArrayList(u8) = .empty;
+    defer output.deinit(allocator);
 
     var lines = std.mem.splitScalar(u8, content, '\n');
     var line_index: usize = 0;
@@ -186,36 +186,38 @@ 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(line);
-                if (lines.rest().len > 0) try output.append('\n');
+                try output.appendSlice(allocator, line);
+                if (lines.rest().len > 0) try output.append(allocator, '\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(line[0..leading_space]);
-                try output.writer().print("version = \"{s}\"", .{new_version});
+                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);
             } else {
-                try output.appendSlice(line);
+                try output.appendSlice(allocator, line);
             }
         } else {
-            try output.appendSlice(line);
+            try output.appendSlice(allocator, line);
         }
 
-        if (lines.rest().len > 0) try output.append('\n');
+        if (lines.rest().len > 0) try output.append(allocator, '\n');
     }
 
-    return try output.toOwnedSlice();
+    return try output.toOwnedSlice(allocator);
 }
 
 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;
@@ -238,8 +240,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).init(allocator);
-    defer output.deinit();
+    var output: std.ArrayList(u8) = .empty;
+    defer output.deinit(allocator);
 
     var pos: usize = 0;
     while (pos < content.len) {
@@ -256,20 +258,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(content[pos..abs_index]);
-                try output.appendSlice(new_version);
+                try output.appendSlice(allocator, content[pos..abs_index]);
+                try output.appendSlice(allocator, new_version);
                 pos = end_index;
             } else {
-                try output.appendSlice(content[pos .. abs_index + 1]);
+                try output.appendSlice(allocator, content[pos .. abs_index + 1]);
                 pos = abs_index + 1;
             }
         } else {
-            try output.appendSlice(remaining);
+            try output.appendSlice(allocator, remaining);
             break;
         }
     }
 
-    return try output.toOwnedSlice();
+    return try output.toOwnedSlice(allocator);
 }
 
 fn isVersionChar(c: u8) bool {
@@ -279,12 +281,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).init(allocator);
+    var files: std.ArrayList([]u8) = .empty;
     errdefer {
         for (files.items) |file| {
             allocator.free(file);
         }
-        files.deinit();
+        files.deinit(allocator);
     }
 
     if (recursive) {
@@ -295,13 +297,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();
+            return files.toOwnedSlice(allocator);
         };
 
-        try files.append(try allocator.dupe(u8, package_json_path));
+        try files.append(allocator, try allocator.dupe(u8, package_json_path));
     }
 
-    return try files.toOwnedSlice();
+    return try files.toOwnedSlice(allocator);
 }
 
 fn findFilesRecursive(allocator: Allocator, files: *std.ArrayList([]u8), dir_path: []const u8) !void {
@@ -332,7 +334,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(try allocator.dupe(u8, full_path));
+                    try files.append(allocator, try allocator.dupe(u8, full_path));
                 }
             },
             else => {},