chore: wip

Author: glennmichael123

build.zig

@@ -1,11 +1,71 @@
 const std = @import("std");
 
 pub fn build(b: *std.Build) void {
-    _ = b.standardTargetOptions(.{});
-    _ = b.standardOptimizeOption(.{});
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
 
-    // Create a module that can be imported by other projects
-    _ = b.addModule("zig-cli", .{
+    // ── Library module (public, exposable to dependents) ────────────────
+    const zig_cli = b.addModule("zig-cli", .{
         .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
     });
+
+    // ── Tests ───────────────────────────────────────────────────────────
+    const test_module = b.createModule(.{
+        .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    const lib_tests = b.addTest(.{
+        .root_module = test_module,
+    });
+    const run_lib_tests = b.addRunArtifact(lib_tests);
+
+    const test_step = b.step("test", "Run library tests");
+    test_step.dependOn(&run_lib_tests.step);
+
+    // ── Examples ────────────────────────────────────────────────────────
+    const example_names = [_][]const u8{
+        "simple",
+        "basic",
+        "typed",
+        "advanced",
+        "prompts",
+        "showcase",
+        "config",
+    };
+
+    const examples_step = b.step("examples", "Build all examples");
+
+    for (example_names) |name| {
+        const example_module = b.createModule(.{
+            .root_source_file = b.path(b.fmt("examples/{s}.zig", .{name})),
+            .target = target,
+            .optimize = optimize,
+            .imports = &.{
+                .{ .name = "zig-cli", .module = zig_cli },
+            },
+        });
+
+        const example = b.addExecutable(.{
+            .name = name,
+            .root_module = example_module,
+        });
+
+        const install_example = b.addInstallArtifact(example, .{});
+        examples_step.dependOn(&install_example.step);
+
+        const run_example = b.addRunArtifact(example);
+        run_example.step.dependOn(&install_example.step);
+        if (b.args) |args| {
+            run_example.addArgs(args);
+        }
+
+        const run_step = b.step(
+            b.fmt("run-{s}", .{name}),
+            b.fmt("Run the {s} example", .{name}),
+        );
+        run_step.dependOn(&run_example.step);
+    }
 }

build.zig.zon

@@ -0,0 +1,13 @@
+.{
+    .name = .zig_cli,
+    .version = "0.1.0",
+    .minimum_zig_version = "0.14.0",
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "examples",
+        "README.md",
+    },
+    .fingerprint = 0xf544320ed4f9c4d7,
+}

examples/advanced.zig

@@ -1,8 +1,10 @@
 const std = @import("std");
 const cli = @import("zig-cli");
 
-fn createAction(ctx: *cli.Command.ParseContext) !void {
-    const stdout = std.io.getStdOut().writer();
+fn createAction(ctx: *cli.BaseCommand.ParseContext) !void {
+    var buf: [4096]u8 = undefined;
+    var file_writer = std.Io.File.stdout().writerStreaming(std.Options.debug_io, &buf);
+    const stdout = &file_writer.interface;
 
     const name = ctx.getArgument(0) orelse return error.MissingName;
     const template = ctx.getOption("template") orelse "default";
@@ -11,10 +13,13 @@ fn createAction(ctx: *cli.Command.ParseContext) !void {
     try stdout.print("Creating project: {s}\n", .{name});
     try stdout.print("Template: {s}\n", .{template});
     try stdout.print("Force: {s}\n", .{if (force) "yes" else "no"});
+    try stdout.flush();
 }
 
-fn buildAction(ctx: *cli.Command.ParseContext) !void {
-    const stdout = std.io.getStdOut().writer();
+fn buildAction(ctx: *cli.BaseCommand.ParseContext) !void {
+    var buf: [4096]u8 = undefined;
+    var file_writer = std.Io.File.stdout().writerStreaming(std.Options.debug_io, &buf);
+    const stdout = &file_writer.interface;
 
     const mode = ctx.getOption("mode") orelse "debug";
     const optimize_str = ctx.getOption("optimize") orelse "false";
@@ -29,10 +34,13 @@ fn buildAction(ctx: *cli.Command.ParseContext) !void {
     while (ctx.getArgument(i)) |target| : (i += 1) {
         try stdout.print("Target: {s}\n", .{target});
     }
+    try stdout.flush();
 }
 
-fn testAction(ctx: *cli.Command.ParseContext) !void {
-    const stdout = std.io.getStdOut().writer();
+fn testAction(ctx: *cli.BaseCommand.ParseContext) !void {
+    var buf: [4096]u8 = undefined;
+    var file_writer = std.Io.File.stdout().writerStreaming(std.Options.debug_io, &buf);
+    const stdout = &file_writer.interface;
 
     const filter = ctx.getOption("filter");
     const verbose = ctx.hasOption("verbose");
@@ -42,24 +50,25 @@ fn testAction(ctx: *cli.Command.ParseContext) !void {
         try stdout.print("Filter: {s}\n", .{f});
     }
     try stdout.print("Verbose: {s}\n", .{if (verbose) "yes" else "no"});
+    try stdout.flush();
 }
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
 
-    // Create CLI application
-    var app = try cli.CLI.init(
+    // Create root command
+    const root_cmd = try cli.BaseCommand.init(
         allocator,
         "advanced-cli",
-        "2.0.0",
         "An advanced CLI application demonstrating complex features",
     );
-    defer app.deinit();
+    defer {
+        root_cmd.deinit();
+        allocator.destroy(root_cmd);
+    }
 
     // Create 'create' command
-    const create_cmd = try cli.Command.init(allocator, "create", "Create a new project");
+    const create_cmd = try cli.BaseCommand.init(allocator, "create", "Create a new project");
 
     const create_name_arg = cli.Argument.init("name", "Project name", .string);
     _ = try create_cmd.addArgument(create_name_arg);
@@ -74,10 +83,10 @@ pub fn main() !void {
     _ = try create_cmd.addOption(force_opt);
 
     _ = create_cmd.setAction(createAction);
-    _ = try app.command(create_cmd);
+    _ = try root_cmd.addCommand(create_cmd);
 
     // Create 'build' command
-    const build_cmd = try cli.Command.init(allocator, "build", "Build the project");
+    const build_cmd = try cli.BaseCommand.init(allocator, "build", "Build the project");
 
     const mode_opt = cli.Option.init("mode", "mode", "Build mode (debug/release)", .string)
         .withShort('m')
@@ -94,10 +103,10 @@ pub fn main() !void {
     _ = try build_cmd.addArgument(targets_arg);
 
     _ = build_cmd.setAction(buildAction);
-    _ = try app.command(build_cmd);
+    _ = try root_cmd.addCommand(build_cmd);
 
     // Create 'test' command
-    const test_cmd = try cli.Command.init(allocator, "test", "Run tests");
+    const test_cmd = try cli.BaseCommand.init(allocator, "test", "Run tests");
 
     const filter_opt = cli.Option.init("filter", "filter", "Filter tests by name", .string)
         .withShort('f');
@@ -108,11 +117,17 @@ pub fn main() !void {
     _ = try test_cmd.addOption(verbose_opt);
 
     _ = test_cmd.setAction(testAction);
-    _ = try app.command(test_cmd);
-
-    // Parse command line arguments
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
+    _ = try root_cmd.addCommand(test_cmd);
+
+    // Collect command line arguments
+    var args_list = std.ArrayList([]const u8){};
+    defer args_list.deinit(allocator);
+    var args_iter = std.process.Args.Iterator.init(init.minimal.args);
+    _ = args_iter.skip(); // skip program name
+    while (args_iter.next()) |arg| {
+        try args_list.append(allocator, arg);
+    }
 
-    try app.parse(args);
+    var parser = cli.Parser.init(allocator);
+    try parser.parse(root_cmd, args_list.items);
 }

examples/basic.zig

@@ -1,33 +1,40 @@
 const std = @import("std");
 const cli = @import("zig-cli");
 
-fn greetAction(ctx: *cli.Command.ParseContext) !void {
+fn greetAction(ctx: *cli.BaseCommand.ParseContext) !void {
     const name = ctx.getOption("name") orelse "World";
     const count_str = ctx.getOption("count") orelse "1";
     const count = try std.fmt.parseInt(usize, count_str, 10);
 
-    const stdout = std.io.getStdOut().writer();
+    var buf: [4096]u8 = undefined;
+    var file_writer = std.Io.File.stdout().writerStreaming(std.Options.debug_io, &buf);
+    const stdout = &file_writer.interface;
 
     var i: usize = 0;
     while (i < count) : (i += 1) {
         try stdout.print("Hello, {s}!\n", .{name});
     }
+    try stdout.flush();
 }
 
-fn infoAction(ctx: *cli.Command.ParseContext) !void {
-    const stdout = std.io.getStdOut().writer();
+fn infoAction(ctx: *cli.BaseCommand.ParseContext) !void {
+    var buf: [4096]u8 = undefined;
+    var file_writer = std.Io.File.stdout().writerStreaming(std.Options.debug_io, &buf);
+    const stdout = &file_writer.interface;
     try stdout.print("This is the info command!\n", .{});
     try stdout.print("Command: {s}\n", .{ctx.command_name});
+    try stdout.flush();
 }
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
 
-    // Create CLI application
-    var app = try cli.CLI.init(allocator, "example", "1.0.0", "An example CLI application");
-    defer app.deinit();
+    // Create root command
+    const root_cmd = try cli.BaseCommand.init(allocator, "example", "An example CLI application");
+    defer {
+        root_cmd.deinit();
+        allocator.destroy(root_cmd);
+    }
 
     // Add options to root command
     const name_option = cli.Option.init("name", "name", "Your name", .string)
@@ -38,21 +45,27 @@ pub fn main() !void {
         .withShort('c')
         .withDefault("1");
 
-    _ = try app.option(name_option);
-    _ = try app.option(count_option);
+    _ = try root_cmd.addOption(name_option);
+    _ = try root_cmd.addOption(count_option);
 
     // Set action for root command
-    _ = app.action(greetAction);
+    _ = root_cmd.setAction(greetAction);
 
     // Create a subcommand
-    const info_cmd = try cli.Command.init(allocator, "info", "Show information");
+    const info_cmd = try cli.BaseCommand.init(allocator, "info", "Show information");
     _ = info_cmd.setAction(infoAction);
 
-    _ = try app.command(info_cmd);
+    _ = try root_cmd.addCommand(info_cmd);
 
-    // Parse command line arguments
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
+    // Collect command line arguments
+    var args_list = std.ArrayList([]const u8){};
+    defer args_list.deinit(allocator);
+    var args_iter = std.process.Args.Iterator.init(init.minimal.args);
+    _ = args_iter.skip(); // skip program name
+    while (args_iter.next()) |arg| {
+        try args_list.append(allocator, arg);
+    }
 
-    try app.parse(args);
+    var parser = cli.Parser.init(allocator);
+    try parser.parse(root_cmd, args_list.items);
 }