fix: correct Zig 0.15.1 API usage (std.fs.File.stdin/stdout/stderr)

Use std.fs.File.stdin()/stdout()/stderr() instead of
std.io.getStdIn()/getStdOut()/getStdErr(). Fix ProgressBar.zig
formatting. Use bufPrint + writeAll pattern for output.

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

Author: chrisbbreuer

src/cli/Help.zig

@@ -11,70 +11,80 @@ pub fn init(allocator: std.mem.Allocator) Help {
 
 pub fn generate(self: *Help, command: *Command, cli_name: []const u8, version: []const u8) !void {
     _ = self;
-    const stdout = std.io.getStdOut().writer();
+    const stdout = std.fs.File.stdout();
 
     // Header
-    try stdout.print("\n{s} v{s}\n", .{ cli_name, version });
-    try stdout.print("{s}\n\n", .{command.description});
+    var buf: [4096]u8 = undefined;
+    var line = try std.fmt.bufPrint(&buf, "\n{s} v{s}\n", .{ cli_name, version });
+    try stdout.writeAll(line);
+    line = try std.fmt.bufPrint(&buf, "{s}\n\n", .{command.description});
+    try stdout.writeAll(line);
 
     // Usage
-    try stdout.print("USAGE:\n", .{});
-    try stdout.print("  {s}", .{command.name});
+    try stdout.writeAll("USAGE:\n");
+    line = try std.fmt.bufPrint(&buf, "  {s}", .{command.name});
+    try stdout.writeAll(line);
 
     if (command.options.items.len > 0) {
-        try stdout.print(" [OPTIONS]", .{});
+        try stdout.writeAll(" [OPTIONS]");
     }
 
     if (command.subcommands.items.len > 0) {
-        try stdout.print(" <COMMAND>", .{});
+        try stdout.writeAll(" <COMMAND>");
     }
 
     for (command.arguments.items) |arg| {
         if (arg.required) {
-            try stdout.print(" <{s}>", .{arg.name});
+            line = try std.fmt.bufPrint(&buf, " <{s}>", .{arg.name});
+            try stdout.writeAll(line);
         } else {
-            try stdout.print(" [{s}]", .{arg.name});
+            line = try std.fmt.bufPrint(&buf, " [{s}]", .{arg.name});
+            try stdout.writeAll(line);
         }
         if (arg.variadic) {
-            try stdout.print("...", .{});
+            try stdout.writeAll("...");
         }
     }
-    try stdout.print("\n\n", .{});
+    try stdout.writeAll("\n\n");
 
     // Arguments
     if (command.arguments.items.len > 0) {
-        try stdout.print("ARGUMENTS:\n", .{});
+        try stdout.writeAll("ARGUMENTS:\n");
         for (command.arguments.items) |arg| {
-            try stdout.print("  <{s}>", .{arg.name});
+            line = try std.fmt.bufPrint(&buf, "  <{s}>", .{arg.name});
+            try stdout.writeAll(line);
             if (arg.variadic) {
-                try stdout.print("...", .{});
+                try stdout.writeAll("...");
             }
             const padding = 20 -| (arg.name.len + 2 + if (arg.variadic) @as(usize, 3) else @as(usize, 0));
-            for (0..padding) |_| try stdout.writeByte(' ');
-            try stdout.print("{s}", .{arg.description});
+            for (0..padding) |_| try stdout.writeAll(" ");
+            line = try std.fmt.bufPrint(&buf, "{s}", .{arg.description});
+            try stdout.writeAll(line);
             if (!arg.required) {
-                try stdout.print(" (optional)", .{});
+                try stdout.writeAll(" (optional)");
             }
-            try stdout.print("\n", .{});
+            try stdout.writeAll("\n");
         }
-        try stdout.print("\n", .{});
+        try stdout.writeAll("\n");
     }
 
     // Options
     if (command.options.items.len > 0) {
-        try stdout.print("OPTIONS:\n", .{});
+        try stdout.writeAll("OPTIONS:\n");
         for (command.options.items) |opt| {
             var length: usize = 0;
 
             if (opt.short) |s| {
-                try stdout.print("  -{c}, ", .{s});
+                line = try std.fmt.bufPrint(&buf, "  -{c}, ", .{s});
+                try stdout.writeAll(line);
                 length += 6;
             } else {
-                try stdout.print("      ", .{});
+                try stdout.writeAll("      ");
                 length += 6;
             }
 
-            try stdout.print("--{s}", .{opt.long});
+            line = try std.fmt.bufPrint(&buf, "--{s}", .{opt.long});
+            try stdout.writeAll(line);
             length += opt.long.len + 2;
 
             if (opt.option_type != .bool) {
@@ -84,40 +94,46 @@ pub fn generate(self: *Help, command: *Command, cli_name: []const u8, version: [
                     .float => "<FLOAT>",
                     .bool => "",
                 };
-                try stdout.print(" {s}", .{type_name});
+                line = try std.fmt.bufPrint(&buf, " {s}", .{type_name});
+                try stdout.writeAll(line);
                 length += type_name.len + 1;
             }
 
             const padding = 30 -| length;
-            for (0..padding) |_| try stdout.writeByte(' ');
+            for (0..padding) |_| try stdout.writeAll(" ");
 
-            try stdout.print("{s}", .{opt.description});
+            line = try std.fmt.bufPrint(&buf, "{s}", .{opt.description});
+            try stdout.writeAll(line);
 
             if (opt.required) {
-                try stdout.print(" (required)", .{});
+                try stdout.writeAll(" (required)");
             } else if (opt.default_value) |default| {
-                try stdout.print(" (default: {s})", .{default});
+                line = try std.fmt.bufPrint(&buf, " (default: {s})", .{default});
+                try stdout.writeAll(line);
             }
 
-            try stdout.print("\n", .{});
+            try stdout.writeAll("\n");
         }
 
-        try stdout.print("  -h, --help", .{});
-        for (0..20) |_| try stdout.writeByte(' ');
-        try stdout.print("Print help\n", .{});
-        try stdout.print("\n", .{});
+        try stdout.writeAll("  -h, --help");
+        for (0..20) |_| try stdout.writeAll(" ");
+        try stdout.writeAll("Print help\n");
+        try stdout.writeAll("\n");
     }
 
     // Commands
     if (command.subcommands.items.len > 0) {
-        try stdout.print("COMMANDS:\n", .{});
+        try stdout.writeAll("COMMANDS:\n");
         for (command.subcommands.items) |subcmd| {
-            try stdout.print("  {s}", .{subcmd.name});
+            line = try std.fmt.bufPrint(&buf, "  {s}", .{subcmd.name});
+            try stdout.writeAll(line);
             const padding = 20 -| subcmd.name.len;
-            for (0..padding) |_| try stdout.writeByte(' ');
-            try stdout.print("{s}\n", .{subcmd.description});
+            for (0..padding) |_| try stdout.writeAll(" ");
+            line = try std.fmt.bufPrint(&buf, "{s}\n", .{subcmd.description});
+            try stdout.writeAll(line);
         }
-        try stdout.print("\n", .{});
-        try stdout.print("Run '{s} <COMMAND> --help' for more information on a command.\n\n", .{command.name});
+        try stdout.writeAll("\n");
+        line = try std.fmt.bufPrint(&buf, "Run '{s} <COMMAND> --help' for more information on a command.\n\n", .{command.name});
+        try stdout.writeAll(line);
     }
 }

src/cli/Middleware.zig

@@ -92,8 +92,10 @@ pub const MiddlewareChain = struct {
 
 /// Logging middleware
 pub fn loggingMiddleware(ctx: *MiddlewareContext) !bool {
-    const stdout = std.io.getStdOut().writer();
-    try stdout.print("[LOG] Executing command: {s}\n", .{ctx.command.name});
+    const stdout = std.fs.File.stdout();
+    var buf: [256]u8 = undefined;
+    const line = try std.fmt.bufPrint(&buf, "[LOG] Executing command: {s}\n", .{ctx.command.name});
+    try stdout.writeAll(line);
     return true;
 }
 
@@ -113,8 +115,10 @@ pub fn validationMiddleware(ctx: *MiddlewareContext) !bool {
     // Check if all required options are present
     for (ctx.command.options.items) |opt| {
         if (opt.required and !ctx.parse_context.hasOption(opt.name)) {
-            const stderr = std.io.getStdErr().writer();
-            try stderr.print("Error: Missing required option '--{s}'\n", .{opt.long});
+            const stderr = std.fs.File.stderr();
+            var buf: [256]u8 = undefined;
+            const line = try std.fmt.bufPrint(&buf, "Error: Missing required option '--{s}'\n", .{opt.long});
+            try stderr.writeAll(line);
             return false;
         }
     }

src/prompt/ProgressBar.zig

@@ -5,10 +5,10 @@ const Ansi = @import("Ansi.zig");
 const ProgressBar = @This();
 
 pub const ProgressBarStyle = enum {
-    bar,        // [=====>    ]
-    blocks,     // ████████░░░
-    dots,       // ⣿⣿⣿⣿⣿⣀⣀⣀⣀⣀
-    ascii,      // [###>      ]
+    bar, // [=====>    ]
+    blocks, // ████████░░░
+    dots, // ⣿⣿⣿⣿⣿⣀⣀⣀⣀⣀
+    ascii, // [###>      ]
 };
 
 terminal: Terminal,

src/prompt/Style.zig

@@ -176,45 +176,52 @@ pub const Style = struct {
         // Build ANSI code sequence
         var codes: std.ArrayList(u8) = .{};
         defer codes.deinit(self.allocator);
+        var tmp_buf: [16]u8 = undefined;
 
         var first = true;
 
         // Styles
         if (self.bold_enabled) {
             if (!first) try codes.append(self.allocator, ';');
-            try codes.print(self.allocator, "{d}", .{Ansi.Style.bold.toCode()});
+            const s = try std.fmt.bufPrint(&tmp_buf, "{d}", .{Ansi.Style.bold.toCode()});
+            try codes.appendSlice(self.allocator, s);
             first = false;
         }
 
         if (self.dim_enabled) {
             if (!first) try codes.append(self.allocator, ';');
-            try codes.print(self.allocator, "{d}", .{Ansi.Style.dim.toCode()});
+            const s = try std.fmt.bufPrint(&tmp_buf, "{d}", .{Ansi.Style.dim.toCode()});
+            try codes.appendSlice(self.allocator, s);
             first = false;
         }
 
         if (self.italic_enabled) {
             if (!first) try codes.append(self.allocator, ';');
-            try codes.print(self.allocator, "{d}", .{Ansi.Style.italic.toCode()});
+            const s = try std.fmt.bufPrint(&tmp_buf, "{d}", .{Ansi.Style.italic.toCode()});
+            try codes.appendSlice(self.allocator, s);
             first = false;
         }
 
         if (self.underline_enabled) {
             if (!first) try codes.append(self.allocator, ';');
-            try codes.print(self.allocator, "{d}", .{Ansi.Style.underline.toCode()});
+            const s = try std.fmt.bufPrint(&tmp_buf, "{d}", .{Ansi.Style.underline.toCode()});
+            try codes.appendSlice(self.allocator, s);
             first = false;
         }
 
         // Foreground color
         if (self.color) |color| {
             if (!first) try codes.append(self.allocator, ';');
-            try codes.print(self.allocator, "{d}", .{color.toCode()});
+            const s = try std.fmt.bufPrint(&tmp_buf, "{d}", .{color.toCode()});
+            try codes.appendSlice(self.allocator, s);
             first = false;
         }
 
         // Background color
         if (self.bg_color) |bg| {
             if (!first) try codes.append(self.allocator, ';');
-            try codes.print(self.allocator, "{d}", .{bg.toCode() + 10}); // BG is FG + 10
+            const s = try std.fmt.bufPrint(&tmp_buf, "{d}", .{bg.toCode() + 10}); // BG is FG + 10
+            try codes.appendSlice(self.allocator, s);
             first = false;
         }
 
@@ -231,7 +238,7 @@ pub const Style = struct {
         const styled = try self.render();
         defer self.allocator.free(styled);
 
-        const stdout = std.io.getStdOut();
+        const stdout = std.fs.File.stdout();
         try stdout.writeAll(styled);
     }
 
@@ -240,7 +247,7 @@ pub const Style = struct {
         const styled = try self.render();
         defer self.allocator.free(styled);
 
-        const stdout = std.io.getStdOut();
+        const stdout = std.fs.File.stdout();
         try stdout.writeAll(styled);
         try stdout.writeAll("\n");
     }

src/prompt/Terminal.zig

@@ -12,7 +12,7 @@ pub const RawMode = struct {
             // Windows terminal setup would go here
             return RawMode{ .original_termios = {} };
         } else {
-            const stdin = std.io.getStdIn();
+            const stdin = std.fs.File.stdin();
             const original = try posix.tcgetattr(stdin.handle);
             var raw = original;
 
@@ -35,7 +35,7 @@ pub const RawMode = struct {
         if (builtin.os.tag == .windows) {
             return;
         }
-        const stdin = std.io.getStdIn();
+        const stdin = std.fs.File.stdin();
         posix.tcsetattr(stdin.handle, .FLUSH, self.original_termios) catch {};
     }
 };
@@ -76,8 +76,8 @@ pub fn init() Terminal {
     const size = detectTerminalSize();
 
     return .{
-        .stdin = std.io.getStdIn(),
-        .stdout = std.io.getStdOut(),
+        .stdin = std.fs.File.stdin(),
+        .stdout = std.fs.File.stdout(),
         .supports_unicode = supports_unicode,
         .supports_color = supports_color,
         .width = size.width,
@@ -132,7 +132,7 @@ fn detectTerminalSize() TerminalSize {
     }
 
     // Try to get terminal size via ioctl
-    const stdout = std.io.getStdOut();
+    const stdout = std.fs.File.stdout();
     var ws: Winsize = undefined;
 
     const result = posix.system.ioctl(stdout.handle, posix.T.IOCGWINSZ, @intFromPtr(&ws));