Zig CLI Deep Dive

const std = @import("std");
const builtin = @import("builtin");

pub fn main() !void {
    // Set up a general-purpose allocator for dynamic memory allocation
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    const allocator = gpa.allocator();
    
    // Retrieve all command-line arguments passed to the program
    const argv = try std.process.argsAlloc(allocator);
    defer std.process.argsFree(allocator, argv);

    // Display the optimization mode used during compilation (Debug, ReleaseSafe, ReleaseFast, ReleaseSmall)
    std.debug.print("optimize-mode: {s}\n", .{@tagName(builtin.mode)});
    
    // Display the target platform triple (architecture-os-abi)
    std.debug.print(
        "target-triple: {s}-{s}-{s}\n",
        .{
            @tagName(builtin.target.cpu.arch),
            @tagName(builtin.target.os.tag),
            @tagName(builtin.target.abi),
        },
    );
    
    // Display whether the program was compiled in single-threaded mode
    std.debug.print("single-threaded: {}\n", .{builtin.single_threaded});

    // Check if any user arguments were provided (argv[0] is the program name itself)
    if (argv.len <= 1) {
        std.debug.print("user-args: <none>\n", .{});
        return;
    }

    // Print all user-provided arguments (skipping the program name at argv[0])
    std.debug.print("user-args:\n", .{});
    for (argv[1..], 0..) |arg, idx| {
        std.debug.print("  arg[{d}] = {s}\n", .{ idx, arg });
    }
}

const std = @import("std");

/// Calculates the sum of all integers in the provided slice.
/// Returns 0 for an empty slice.
fn sum(values: []const i32) i32 {
    var total: i32 = 0;
    // Accumulate all values in the slice
    for (values) |value| total += value;
    return total;
}

/// Calculates the product of all integers in the provided slice.
/// Returns 1 for an empty slice (multiplicative identity).
fn product(values: []const i32) i32 {
    var total: i32 = 1;
    // Multiply each value with the running total
    for (values) |value|
        total *= value;
    return total;
}

// Verifies that sum correctly adds positive integers
test "sum-of-three" {
    try std.testing.expectEqual(@as(i32, 42), sum(&.{ 20, 10, 12 }));
}

// Verifies that sum handles mixed positive and negative integers correctly
test "sum-mixed-signs" {
    try std.testing.expectEqual(@as(i32, -1), sum(&.{ 4, -3, -2 }));
}

// Verifies that product correctly multiplies positive integers
test "product-positive" {
    try std.testing.expectEqual(@as(i32, 120), product(&.{ 2, 3, 4, 5 }));
}

// Verifies that product correctly handles negative integers,
// resulting in a negative product when an odd number of negatives are present
test "product-negative" {
    try std.testing.expectEqual(@as(i32, -18), product(&.{ 3, -3, 2 }));
}

//! Utility functions for CLI environment configuration and cross-platform defaults.
//! This module provides helpers for determining cache directories, color support,
//! and default tool configurations based on the target operating system.
const std = @import("std");
const builtin = @import("builtin");

/// Returns the appropriate environment variable key for the cache directory
/// based on the target operating system.
///
/// - Windows uses LOCALAPPDATA for application cache
/// - macOS and iOS use HOME (cache typically goes in ~/Library/Caches)
/// - Unix-like systems prefer XDG_CACHE_HOME for XDG Base Directory compliance
/// - Other systems fall back to HOME directory
pub fn defaultCacheEnvKey() []const u8 {
    return switch (builtin.os.tag) {
        .windows => "LOCALAPPDATA",
        .macos => "HOME",
        .ios => "HOME",
        .linux, .freebsd, .netbsd, .openbsd, .dragonfly, .haiku => "XDG_CACHE_HOME",
        else => "HOME",
    };
}

/// Determines whether ANSI color codes should be used in terminal output
/// based on standard environment variables.
///
/// Follows the informal standard where:
/// - NO_COLOR (any value) disables colors
/// - CLICOLOR_FORCE (any value) forces colors even if not a TTY
/// - Default behavior is to enable colors
///
/// Returns true if ANSI colors should be used, false otherwise.
pub fn preferAnsiColor(env: std.process.EnvMap) bool {
    // Check if colors are explicitly disabled
    if (env.get("NO_COLOR")) |_| return false;
    // Check if colors are explicitly forced
    if (env.get("CLICOLOR_FORCE")) |_| return true;
    // Default to enabling colors
    return true;
}

/// Returns the default command-line arguments for invoking the Zig formatter
/// in check mode (reports formatting issues without modifying files).
pub fn defaultFormatterArgs() []const []const u8 {
    return &.{ "zig", "fmt", "--check" };
}