tiny.smg.cli.options

1const std = @import("std");2const smg = @import("../root.zig");34const text = smg.text;56pub const max_source_file_bytes_option = "--max-source-file-bytes";7pub const max_fragment_bytes_option = "--max-fragment-bytes";8pub const max_git_file_list_bytes_option = "--max-git-file-list-bytes";9pub const wal_recovery_limit_bytes_option = "--wal-recovery-limit-bytes";1011pub const byte_limit_options = [_][]const u8{12    max_source_file_bytes_option,13    max_fragment_bytes_option,14    max_git_file_list_bytes_option,15    wal_recovery_limit_bytes_option,16};1718pub const ByteLimitFailure = struct {19    option: []const u8,20    value: []const u8,21    reason: Reason,2223    pub const Reason = enum {24        invalid_size,25        capacity_overflow,26        fragment_header,27    };28};2930pub const LimitsResult = union(enum) {31    limits: smg.Limits,32    invalid: ByteLimitFailure,33};3435pub fn positional(allocator: std.mem.Allocator, args: []const []const u8) ![]const []const u8 {36    var out: std.ArrayList([]const u8) = .empty;37    var i: usize = 0;38    while (i < args.len) : (i += 1) {39        const arg = args[i];40        if (std.mem.startsWith(u8, arg, "--")) {41            if (takesValue(arg) and inlineOptionValue(arg) == null and i + 1 < args.len) i += 1;42            continue;43        }44        try out.append(allocator, arg);45    }46    return try out.toOwnedSlice(allocator);47}4849fn takesValue(flag: []const u8) bool {50    const valued = [_][]const u8{51        "--file",52        "--line",53        "--doc",54        "--meta",55        "--type",56        "--rel",57        "--format",58        "--limit",59        "--depth",60        "--top",61        "--module",62        "--kind",63        "--level",64        "--since",65        "--churn-days",66        "--deny",67        "--exclude-source",68        "--invariant",69        "--forall",70        "--assert",71        "--scope",72        "--prefix",73        "--sync-point",74        "--tokens",75        "--entry-points",76        "--baseline",77        "--debounce",78        "--exclude",79        max_source_file_bytes_option,80        max_fragment_bytes_option,81        max_git_file_list_bytes_option,82        wal_recovery_limit_bytes_option,83    };84    const name = optionName(flag);85    for (valued) |item| if (std.mem.eql(u8, name, item)) return true;86    return false;87}8889pub fn optionName(arg: []const u8) []const u8 {90    if (!std.mem.startsWith(u8, arg, "--")) return arg;91    const equals = std.mem.indexOfScalar(u8, arg, '=') orelse return arg;92    return arg[0..equals];93}9495pub fn inlineOptionValue(arg: []const u8) ?[]const u8 {96    if (!std.mem.startsWith(u8, arg, "--")) return null;97    const equals = std.mem.indexOfScalar(u8, arg, '=') orelse return null;98    return arg[equals + 1 ..];99}100101pub fn hasFlag(args: []const []const u8, flag: []const u8) bool {102    for (args) |arg| if (std.mem.eql(u8, arg, flag)) return true;103    return false;104}105106pub fn flagValue(args: []const []const u8, flag: []const u8) ?[]const u8 {107    var i: usize = 0;108    while (i + 1 < args.len) : (i += 1) {109        if (std.mem.eql(u8, optionName(args[i]), flag)) {110            if (inlineOptionValue(args[i])) |value| return value;111        }112        if (std.mem.eql(u8, args[i], flag)) return args[i + 1];113    }114    if (args.len != 0 and std.mem.eql(u8, optionName(args[args.len - 1]), flag)) {115        if (inlineOptionValue(args[args.len - 1])) |value| return value;116    }117    return null;118}119120pub fn flagValues(allocator: std.mem.Allocator, args: []const []const u8, flag: []const u8) ![]const []const u8 {121    var out: std.ArrayList([]const u8) = .empty;122    var i: usize = 0;123    while (i + 1 < args.len) : (i += 1) {124        if (std.mem.eql(u8, optionName(args[i]), flag)) {125            if (inlineOptionValue(args[i])) |value| {126                try out.append(allocator, value);127                continue;128            }129        }130        if (std.mem.eql(u8, args[i], flag)) {131            try out.append(allocator, args[i + 1]);132            i += 1;133        }134    }135    if (args.len != 0 and std.mem.eql(u8, optionName(args[args.len - 1]), flag)) {136        if (inlineOptionValue(args[args.len - 1])) |value| try out.append(allocator, value);137    }138    return try out.toOwnedSlice(allocator);139}140141pub fn hasJson(args: []const []const u8) bool {142    return hasFlag(args, "--json") or std.mem.eql(u8, flagValue(args, "--format") orelse "", "json");143}144145pub fn signedLimitValue(args: []const []const u8) i64 {146    return signedOptionValue(args, "--limit", 20);147}148149pub fn signedOptionValue(args: []const []const u8, option: []const u8, default: i64) i64 {150    return if (flagValue(args, option)) |raw| std.fmt.parseInt(i64, raw, 10) catch default else default;151}152153pub fn storageLimit(limit: i64) usize {154    return if (limit > 0) @intCast(limit) else 0;155}156157pub fn slicedLen(total: usize, limit: i64) usize {158    if (limit == 0) return total;159    if (limit > 0) return @min(total, @as(usize, @intCast(limit)));160    const magnitude = if (limit == std.math.minInt(i64)) std.math.maxInt(u64) else @as(u64, @intCast(-limit));161    const total_u64 = @as(u64, @intCast(total));162    if (magnitude >= total_u64) return 0;163    return @intCast(total_u64 - magnitude);164}165166pub fn searchLimitValue(args: []const []const u8) i64 {167    return text.parseInt(flagValue(args, "--limit") orelse "10", 10);168}169170pub fn depthValue(args: []const []const u8) ?usize {171    _ = flagValue(args, "--depth") orelse return null;172    return unsignedTraversalDepth(signedOptionValue(args, "--depth", 0));173}174175pub fn unsignedTraversalDepth(depth: i64) usize {176    return if (depth > 0) @intCast(depth) else 0;177}178179pub fn couplingOnlyValue(args: []const []const u8) bool {180    var value = true;181    for (args) |arg| {182        if (std.mem.eql(u8, arg, "--coupling-only")) value = true;183        if (std.mem.eql(u8, arg, "--all-rels")) value = false;184    }185    return value;186}187188pub fn parseByteSize(raw: []const u8) error{ InvalidByteSize, CapacityOverflow }!usize {189    const Unit = struct {190        suffix: []const u8,191        multiplier: usize,192    };193    const units = [_]Unit{194        .{ .suffix = "GiB", .multiplier = 1024 * 1024 * 1024 },195        .{ .suffix = "MiB", .multiplier = 1024 * 1024 },196        .{ .suffix = "KiB", .multiplier = 1024 },197        .{ .suffix = "B", .multiplier = 1 },198    };199    var digits = raw;200    var multiplier: usize = 1;201    for (units) |unit| {202        if (!std.mem.endsWith(u8, raw, unit.suffix)) continue;203        digits = raw[0 .. raw.len - unit.suffix.len];204        multiplier = unit.multiplier;205        break;206    }207    if (digits.len == 0) return error.InvalidByteSize;208    const value = std.fmt.parseUnsigned(usize, digits, 10) catch |err| switch (err) {209        error.InvalidCharacter => return error.InvalidByteSize,210        error.Overflow => return error.CapacityOverflow,211    };212    if (value == 0) return error.InvalidByteSize;213    return std.math.mul(usize, value, multiplier) catch error.CapacityOverflow;214}215216pub fn configuredLimits(args: []const []const u8, base: smg.Limits) LimitsResult {217    var limits = base;218    for (byte_limit_options) |option| {219        const raw = flagValue(args, option) orelse continue;220        const value = parseByteSize(raw) catch |err| return .{ .invalid = .{221            .option = option,222            .value = raw,223            .reason = switch (err) {224                error.InvalidByteSize => .invalid_size,225                error.CapacityOverflow => .capacity_overflow,226            },227        } };228        if (std.mem.eql(u8, option, max_source_file_bytes_option)) {229            limits.scan.max_source_file_bytes = value;230        } else if (std.mem.eql(u8, option, max_fragment_bytes_option)) {231            if (value <= std.crypto.hash.sha2.Sha256.digest_length) return .{ .invalid = .{232                .option = option,233                .value = raw,234                .reason = .fragment_header,235            } };236            limits.scan.max_fragment_bytes = value;237        } else if (std.mem.eql(u8, option, max_git_file_list_bytes_option)) {238            limits.scan.max_git_file_list_bytes = value;239        } else if (std.mem.eql(u8, option, wal_recovery_limit_bytes_option)) {240            limits.storage.wal_recovery_limit_bytes = value;241        } else unreachable;242    }243    _ = limits.derive() catch unreachable;244    return .{ .limits = limits };245}246247test "positional skips valued flags" {248    const args = [_][]const u8{ "name", "--limit", "3", "--json", "tail", "--top", "4", "--exclude", ".zig-cache", "--module", "app", "--baseline", "1:digest" };249    const pos = try positional(std.testing.allocator, &args);250    defer std.testing.allocator.free(pos);251    try std.testing.expectEqual(@as(usize, 2), pos.len);252    try std.testing.expectEqualStrings("name", pos[0]);253    try std.testing.expectEqualStrings("tail", pos[1]);254}255256test "signed option helpers preserve click-shaped values" {257    const limit = [_][]const u8{ "--limit", "-1" };258    try std.testing.expectEqual(@as(i64, -1), signedLimitValue(&limit));259    const inline_limit = [_][]const u8{"--limit=-2"};260    try std.testing.expectEqual(@as(i64, -2), signedLimitValue(&inline_limit));261    const inline_format = [_][]const u8{"--format=json"};262    try std.testing.expectEqualStrings("json", flagValue(&inline_format, "--format").?);263}264265test "slice and storage limits preserve signed semantics" {266    try std.testing.expectEqual(@as(usize, 7), slicedLen(7, 0));267    try std.testing.expectEqual(@as(usize, 2), slicedLen(7, 2));268    try std.testing.expectEqual(@as(usize, 6), slicedLen(7, -1));269    try std.testing.expectEqual(@as(usize, 0), slicedLen(7, -20));270    try std.testing.expectEqual(@as(usize, 0), storageLimit(-1));271    try std.testing.expectEqual(@as(usize, 4), storageLimit(4));272}273274test "depth and relationship options preserve python semantics" {275    const deps_depth = [_][]const u8{ "--depth", "-1" };276    try std.testing.expectEqual(@as(?usize, 0), depthValue(&deps_depth));277    const all_then_coupling = [_][]const u8{ "--all-rels", "--coupling-only" };278    try std.testing.expect(couplingOnlyValue(&all_then_coupling));279    const coupling_then_all = [_][]const u8{ "--coupling-only", "--all-rels" };280    try std.testing.expect(!couplingOnlyValue(&coupling_then_all));281}282283test "byte size parser accepts binary units and rejects invalid capacities" {284    try std.testing.expectEqual(@as(usize, 32 * 1024 * 1024), try parseByteSize("32MiB"));285    try std.testing.expectEqual(@as(usize, 4096), try parseByteSize("4KiB"));286    try std.testing.expectEqual(@as(usize, 17), try parseByteSize("17"));287    try std.testing.expectEqual(@as(usize, 17), try parseByteSize("17B"));288    try std.testing.expectError(error.InvalidByteSize, parseByteSize("0"));289    try std.testing.expectError(error.InvalidByteSize, parseByteSize("32MB"));290    try std.testing.expectError(error.CapacityOverflow, parseByteSize("999999999999999999999999GiB"));291}292293test "configured limits map human options to their owners" {294    const args = [_][]const u8{295        "--max-source-file-bytes=48MiB",296        "--max-fragment-bytes",297        "384MiB",298        "--max-git-file-list-bytes=96MiB",299        "--wal-recovery-limit-bytes",300        "512MiB",301    };302    const configured = configuredLimits(&args, smg.default_limits).limits;303    try std.testing.expectEqual(@as(usize, 48 * 1024 * 1024), configured.scan.max_source_file_bytes);304    try std.testing.expectEqual(@as(usize, 384 * 1024 * 1024), configured.scan.max_fragment_bytes);305    try std.testing.expectEqual(@as(usize, 96 * 1024 * 1024), configured.scan.max_git_file_list_bytes);306    try std.testing.expectEqual(@as(usize, 512 * 1024 * 1024), configured.storage.wal_recovery_limit_bytes);307}

1pub const options = @import("options.zig");