Build Zig skeleton with canonical checks

src/main.zig

@@ -0,0 +1,90 @@
+const std = @import("std");
+
+pub const version = "0.1.0-dev";
+
+const help_text =
+    \\mim - mobile-first terminal code editor for SSH sessions
+    \\
+    \\Usage:
+    \\  mim [--help]
+    \\  mim [--version]
+    \\
+    \\This skeleton intentionally starts with only the canonical smoke path.
+    \\Future editor behavior is added through verified product slices.
+    \\
+;
+
+const Command = union(enum) {
+    help,
+    version,
+    smoke,
+    unknown: []const u8,
+};
+
+fn parseArgs(args: []const []const u8) Command {
+    if (args.len <= 1) return .smoke;
+
+    const arg = args[1];
+    if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) return .help;
+    if (std.mem.eql(u8, arg, "--version")) return .version;
+    return .{ .unknown = arg };
+}
+
+fn versionText() []const u8 {
+    return "mim " ++ version ++ "\n";
+}
+
+pub fn main(init: std.process.Init) !u8 {
+    var args = std.process.Args.Iterator.init(init.minimal.args);
+    _ = args.skip();
+
+    const first_arg = args.next();
+    const command = if (first_arg) |arg|
+        parseArgs(&.{ "mim", arg })
+    else
+        parseArgs(&.{"mim"});
+
+    const stdout = std.Io.File.stdout();
+    const stderr = std.Io.File.stderr();
+
+    switch (command) {
+        .help => try stdout.writeStreamingAll(init.io, help_text),
+        .version => try stdout.writeStreamingAll(init.io, versionText()),
+        .smoke => try stdout.writeStreamingAll(init.io, help_text),
+        .unknown => |arg| {
+            try stderr.writeStreamingAll(init.io, "mim: unknown argument '");
+            try stderr.writeStreamingAll(init.io, arg);
+            try stderr.writeStreamingAll(init.io, "'\nTry 'mim --help'.\n");
+            return 64;
+        },
+    }
+
+    return 0;
+}
+
+test "regular: help text names the binary and smoke boundary" {
+    try std.testing.expect(std.mem.indexOf(u8, help_text, "mim - mobile-first terminal code editor") != null);
+    try std.testing.expect(std.mem.indexOf(u8, help_text, "canonical smoke path") != null);
+}
+
+test "regular: version output is stable enough for smoke checks" {
+    try std.testing.expectEqualStrings("mim 0.1.0-dev\n", versionText());
+}
+
+test "adversarial: unknown arguments are rejected instead of ignored" {
+    const argv = [_][]const u8{ "mim", "--definitely-not-supported" };
+    const parsed = parseArgs(&argv);
+    switch (parsed) {
+        .unknown => |arg| try std.testing.expectEqualStrings("--definitely-not-supported", arg),
+        else => return error.ExpectedUnknownArgument,
+    }
+}
+
+test "adversarial: extra positional arguments are not treated as files yet" {
+    const argv = [_][]const u8{ "mim", "some-file.zig" };
+    const parsed = parseArgs(&argv);
+    switch (parsed) {
+        .unknown => |arg| try std.testing.expectEqualStrings("some-file.zig", arg),
+        else => return error.ExpectedUnknownArgument,
+    }
+}