const std = @import("std");const command_classification = @import("../shell_command/command_classification.zig"); const RiskKind = enum {    discard_version_control_state,    forceful_file_removal,}; /// Returns a short policy note for command text with a high-risk shape.pub fn command_risk_note_for(command: []const u8) ?[]const u8 {    const analysis = command_classification.analysis_command_tail(command);    const risk = risk_kind_in_analysis(analysis) orelse return null;    return risk_note_for(risk);} /// Returns a narrow alternative when the command text has an unambiguous safer path.pub fn command_safer_alternative_for(command: []const u8) ?[]const u8 {    const analysis = command_classification.analysis_command_tail(command);    if (risk_kind_in_analysis(analysis)) |risk| {        return safer_alternative_for_risk(risk);    }     if (has_shell_boundary(command)) return null;    const base = command_classification.base_command_token(analysis) orelse return null;    if (std.mem.eql(u8, base, "cat") or std.mem.eql(u8, base, "less") or std.mem.eql(u8, base, "more")) {        return "safer: use read_file for file inspection";    }    if (std.mem.eql(u8, base, "ls")) {        return "safer: use list_files or glob_files for discovery";    }    if (is_pattern_matcher(base)) {        return "safer: use grep_files for exact local search";    }    if (std.mem.eql(u8, base, "find")) {        return "safer: use glob_files or list_files for discovery";    }    return null;} fn risk_note_for(risk: RiskKind) []const u8 {    return switch (risk) {        .discard_version_control_state => "note: command may discard version-control state",        .forceful_file_removal => "note: command may remove files forcefully",    };} fn safer_alternative_for_risk(risk: RiskKind) []const u8 {    return switch (risk) {        .discard_version_control_state => "safer: inspect git status first and revert only the intended files",        .forceful_file_removal => "safer: inspect targets first or use delete_file for explicit files",    };} /// Returns an informational annotation for non-error non-zero exit codes.pub fn semantic_exit_annotation(command_text: []const u8, exit_code: i64, stderr_text: []const u8) ?[]const u8 {    if (exit_code == 0) return null;     const analysis = command_classification.analysis_command_tail(command_text);    const terminal = command_classification.terminal_exit_segment(analysis) orelse return null;    const base = command_classification.base_command_token(terminal) orelse return null;     if (is_pattern_matcher(base)) {        return if (exit_code == 1) "note: no matches found" else null;    }    if (std.mem.eql(u8, base, "find")) {        if (exit_code != 1 or !looks_like_find_access_issue(stderr_text)) return null;        return "note: some paths could not be read";    }    if (std.mem.eql(u8, base, "diff") or std.mem.eql(u8, base, "cmp")) {        return if (exit_code == 1) "note: compared files differ" else null;    }    if (std.mem.eql(u8, base, "test") or std.mem.eql(u8, base, "[")) {        return if (exit_code == 1) "note: condition evaluated false" else null;    }    return null;} fn risk_kind_in_analysis(command: []const u8) ?RiskKind {    if (warning_at_command_position(command)) |risk| return risk;     var in_single = false;    var in_double = false;    var escaped = false;    var i: usize = 0;    while (i < command.len) : (i += 1) {        const ch = command[i];        if (escaped) {            escaped = false;            continue;        }        if (ch == '\\' and !in_single) {            escaped = true;            continue;        }        if (ch == '\'' and !in_double) {            in_single = !in_single;            continue;        }        if (ch == '"' and !in_single) {            in_double = !in_double;            continue;        }        if (in_single or in_double) continue;         const boundary_end = switch (ch) {            ';', '\n', '&' => blk: {                if (ch == '&' and i + 1 < command.len and command[i + 1] == '&') {                    i += 1;                    break :blk i + 1;                }                break :blk i + 1;            },            '|' => blk: {                if (i + 1 < command.len and command[i + 1] == '|') {                    i += 1;                    break :blk i + 1;                }                break :blk i + 1;            },            else => continue,        };        if (warning_at_command_position(command[boundary_end..])) |risk| return risk;    }    return null;} fn warning_at_command_position(command: []const u8) ?RiskKind {    var cursor = command_classification.skip_whitespace(command, 0);    while (command_classification.next_token(command, cursor)) |token| {        if (!command_classification.is_env_assignment(token.text)) break;        cursor = token.end;    }    const first = command_classification.next_token(command, cursor) orelse return null;     if (privileged_command_tail(command, first)) |tail| {        if (warning_at_command_position(tail)) |risk| return risk;    }     const rest = command[first.end..];    if (git_hard_reset(first.text, rest)) |risk| return risk;    if (forceful_file_removal(first.text, rest)) |risk| return risk;    return null;} fn privileged_command_tail(command: []const u8, first: command_classification.Token) ?[]const u8 {    if (std.mem.eql(u8, first.text, "sudo") or std.mem.eql(u8, first.text, "doas")) {        return sudo_like_command_tail(command, first.end);    }    if (std.mem.eql(u8, first.text, "su")) {        return su_command_tail(command, first.end);    }    return null;} fn sudo_like_command_tail(command: []const u8, start: usize) ?[]const u8 {    var cursor = start;    while (command_classification.next_token(command, cursor)) |token| {        if (std.mem.eql(u8, token.text, "--")) {            const next = command_classification.next_token(command, token.end) orelse return null;            return command[next.start..];        }        if (command_classification.is_env_assignment(token.text)) {            cursor = token.end;            continue;        }        if (std.mem.startsWith(u8, token.text, "-")) {            if (privilege_option_takes_value(token.text)) {                const value = command_classification.next_token(command, token.end) orelse return null;                cursor = value.end;            } else {                cursor = token.end;            }            continue;        }        return command[token.start..];    }    return null;} fn privilege_option_takes_value(option: []const u8) bool {    return std.mem.eql(u8, option, "-u") or        std.mem.eql(u8, option, "-g") or        std.mem.eql(u8, option, "-h") or        std.mem.eql(u8, option, "-p") or        std.mem.eql(u8, option, "-C") or        std.mem.eql(u8, option, "-T") or        std.mem.eql(u8, option, "-U") or        std.mem.eql(u8, option, "--user") or        std.mem.eql(u8, option, "--group") or        std.mem.eql(u8, option, "--host") or        std.mem.eql(u8, option, "--prompt") or        std.mem.eql(u8, option, "--close-from") or        std.mem.eql(u8, option, "--command-timeout") or        std.mem.eql(u8, option, "--other-user");} fn su_command_tail(command: []const u8, start: usize) ?[]const u8 {    var cursor = start;    while (command_classification.next_token(command, cursor)) |token| {        if (std.mem.eql(u8, token.text, "-c")) {            return parse_su_command_argument(command, token.end);        }        cursor = token.end;    }    return null;} fn parse_su_command_argument(command: []const u8, start: usize) ?[]const u8 {    const cursor = command_classification.skip_whitespace(command, start);    if (cursor >= command.len) return null;     const quote = command[cursor];    if (quote == '\'' or quote == '"') {        const payload_start = cursor + 1;        var escaped = false;        var i = payload_start;        while (i < command.len) : (i += 1) {            const ch = command[i];            if (escaped) {                escaped = false;                continue;            }            if (quote == '"' and ch == '\\') {                escaped = true;                continue;            }            if (ch == quote) return command[payload_start..i];        }        return null;    }     const token = command_classification.next_token(command, cursor) orelse return null;    return token.text;} fn git_hard_reset(command_name: []const u8, rest: []const u8) ?RiskKind {    if (!std.mem.eql(u8, command_name, "git")) return null;     const sub = command_classification.next_token(rest, 0) orelse return null;    const args = rest[sub.end..];     if (std.mem.eql(u8, sub.text, "reset") and has_token(args, "--hard")) {        return .discard_version_control_state;    }    return null;} fn forceful_file_removal(command_name: []const u8, rest: []const u8) ?RiskKind {    if (!std.mem.eql(u8, command_name, "rm")) return null;     var has_recursive = false;    var has_force = false;    var cursor: usize = 0;    while (command_classification.next_token(rest, cursor)) |token| {        cursor = token.end;        if (!std.mem.startsWith(u8, token.text, "-")) continue;        if (std.mem.eql(u8, token.text, "--recursive") or std.mem.eql(u8, token.text, "-r") or std.mem.eql(u8, token.text, "-R")) has_recursive = true;        if (std.mem.eql(u8, token.text, "--force") or std.mem.eql(u8, token.text, "-f")) has_force = true;        if (token.text.len > 1 and token.text[1] != '-') {            for (token.text[1..]) |ch| {                if (ch == 'r' or ch == 'R') has_recursive = true;                if (ch == 'f') has_force = true;            }        }    }    return if (has_recursive or has_force) .forceful_file_removal else null;} fn is_pattern_matcher(command: []const u8) bool {    return std.mem.eql(u8, command, "grep") or        std.mem.eql(u8, command, "egrep") or        std.mem.eql(u8, command, "fgrep") or        std.mem.eql(u8, command, "rg") or        std.mem.eql(u8, command, "ag");} fn looks_like_find_access_issue(stderr_text: []const u8) bool {    return contains_ascii_ignore_case(stderr_text, "permission denied") or        contains_ascii_ignore_case(stderr_text, "operation not permitted");} fn has_token(rest: []const u8, needle: []const u8) bool {    var cursor: usize = 0;    while (command_classification.next_token(rest, cursor)) |token| {        cursor = token.end;        if (std.mem.eql(u8, token.text, needle)) return true;    }    return false;} fn contains_ascii_ignore_case(haystack: []const u8, needle: []const u8) bool {    if (needle.len == 0) return true;    if (haystack.len < needle.len) return false;    var i: usize = 0;    while (i + needle.len <= haystack.len) : (i += 1) {        if (ascii_eql_ignore_case(haystack[i .. i + needle.len], needle)) return true;    }    return false;} fn ascii_eql_ignore_case(a: []const u8, b: []const u8) bool {    if (a.len != b.len) return false;    for (a, b) |left, right| {        if (std.ascii.toLower(left) != std.ascii.toLower(right)) return false;    }    return true;} fn has_shell_boundary(command: []const u8) bool {    return std.mem.findScalar(u8, command, ';') != null or        std.mem.findScalar(u8, command, '&') != null or        std.mem.findScalar(u8, command, '|') != null or        std.mem.findScalar(u8, command, '<') != null or        std.mem.findScalar(u8, command, '>') != null or        std.mem.findScalar(u8, command, '$') != null or        std.mem.findScalar(u8, command, '`') != null or        std.mem.findScalar(u8, command, '\n') != null;} test "command risk note detects git hard reset" {    try std.testing.expectEqualStrings("note: command may discard version-control state", command_risk_note_for("git reset --hard").?);} test "command safer alternative explains risky commands" {    try std.testing.expectEqualStrings("safer: inspect git status first and revert only the intended files", command_safer_alternative_for("git reset --hard").?);    try std.testing.expectEqualStrings("safer: inspect targets first or use delete_file for explicit files", command_safer_alternative_for("rm -rf /tmp/x").?);} test "command safer alternative maps shell inspection to dedicated tools" {    try std.testing.expectEqualStrings("safer: use read_file for file inspection", command_safer_alternative_for("cat src/main.zig").?);    try std.testing.expectEqualStrings("safer: use list_files or glob_files for discovery", command_safer_alternative_for("ls src").?);    try std.testing.expectEqualStrings("safer: use grep_files for exact local search", command_safer_alternative_for("rg needle src").?);    try std.testing.expectEqualStrings("safer: use glob_files or list_files for discovery", command_safer_alternative_for("find src -name '*.zig'").?);} test "command safer alternative stays conservative for compound commands" {    try std.testing.expect(command_safer_alternative_for("cat src/main.zig | wc -l") == null);    try std.testing.expect(command_safer_alternative_for("git status") == null);} test "command risk note stays narrow for ordinary git operations" {    try std.testing.expect(command_risk_note_for("git status") == null);    try std.testing.expect(command_risk_note_for("git log --oneline") == null);    try std.testing.expect(command_risk_note_for("git commit --no-verify -m ok") == null);} test "command risk note detects forceful removal" {    try std.testing.expectEqualStrings("note: command may remove files forcefully", command_risk_note_for("rm -rf /tmp/x").?);} test "command risk note detects privilege-wrapped removal" {    try std.testing.expectEqualStrings("note: command may remove files forcefully", command_risk_note_for("sudo rm -rf /tmp").?);    try std.testing.expectEqualStrings("note: command may remove files forcefully", command_risk_note_for("doas rm -rf /tmp").?);} test "command risk note detects privilege-wrapped git reset" {    try std.testing.expectEqualStrings("note: command may discard version-control state", command_risk_note_for("sudo git reset --hard").?);} test "command risk note detects quoted su command payload" {    try std.testing.expectEqualStrings("note: command may remove files forcefully", command_risk_note_for("su -c 'rm -rf /tmp'").?);    try std.testing.expectEqualStrings("note: command may discard version-control state", command_risk_note_for("su -c \"git reset --hard\"").?);    try std.testing.expectEqualStrings("note: command may remove files forcefully", command_risk_note_for("su root -c 'rm -rf /tmp'").?);} test "command risk note fails closed for malformed su command payload" {    try std.testing.expect(command_risk_note_for("su -c 'rm -rf /tmp") == null);    try std.testing.expect(command_risk_note_for("su -c \"git reset --hard") == null);} test "command risk note detects process-control wrapped removal" {    try std.testing.expect(command_risk_note_for("nice rm -rf /tmp") != null);} test "command risk note detects timeout wrapped git reset" {    try std.testing.expect(command_risk_note_for("timeout 5 git reset --hard") != null);} test "command risk note detects safe env wrapped git reset" {    try std.testing.expect(command_risk_note_for("env NODE_ENV=prod git reset --hard") != null);} test "command risk note sees removal after unknown env prefix" {    try std.testing.expectEqualStrings("note: command may remove files forcefully", command_risk_note_for("MY_SECRET=x rm -rf /tmp").?);} test "command risk note ignores quoted command text" {    try std.testing.expect(command_risk_note_for("echo 'rm -rf /tmp'") == null);} test "command risk note ignores command text in argument string" {    try std.testing.expect(command_risk_note_for("git commit -m \"rm -rf /tmp\"") == null);} test "command risk note detects command after sequence boundary" {    try std.testing.expect(command_risk_note_for("echo ok; rm -f scratch") != null);} test "semantic annotation explains grep exit one" {    try std.testing.expectEqualStrings("note: no matches found", semantic_exit_annotation("grep foo bar", 1, "").?);} test "semantic annotation leaves grep real errors alone" {    try std.testing.expect(semantic_exit_annotation("grep foo bar", 2, "") == null);} test "semantic annotation leaves zero exits alone" {    try std.testing.expect(semantic_exit_annotation("grep foo bar", 0, "") == null);} test "semantic annotation explains find partial access" {    try std.testing.expectEqualStrings("note: some paths could not be read", semantic_exit_annotation("find /tmp -name foo", 1, "find: /tmp/private: Permission denied").?);    try std.testing.expectEqualStrings("note: some paths could not be read", semantic_exit_annotation("find /tmp -name foo", 1, "find: /tmp/private: Operation not permitted").?);} test "semantic annotation leaves find usage errors alone" {    try std.testing.expect(semantic_exit_annotation("find /tmp -bad", 1, "find: -bad: unknown primary or operator") == null);    try std.testing.expect(semantic_exit_annotation("find /tmp -name", 1, "find: -name: requires additional arguments") == null);} test "semantic annotation explains diff differences" {    try std.testing.expectEqualStrings("note: compared files differ", semantic_exit_annotation("diff a b", 1, "").?);} test "semantic annotation explains test false" {    try std.testing.expectEqualStrings("note: condition evaluated false", semantic_exit_annotation("test -f foo", 1, "").?);} test "semantic annotation explains bracket alias false" {    try std.testing.expectEqualStrings("note: condition evaluated false", semantic_exit_annotation("[ -f foo ]", 1, "").?);} test "semantic annotation handles wrapped grep" {    try std.testing.expectEqualStrings("note: no matches found", semantic_exit_annotation("timeout 5 grep foo bar.txt", 1, "").?);} test "semantic annotation uses last pipe segment" {    try std.testing.expectEqualStrings("note: no matches found", semantic_exit_annotation("diff a b | grep changed", 1, "").?);} test "semantic annotation uses last sequence segment" {    try std.testing.expectEqualStrings("note: no matches found", semantic_exit_annotation("ls -la; grep foo bar.txt", 1, "").?);} test "semantic annotation uses last newline segment" {    try std.testing.expectEqualStrings("note: no matches found", semantic_exit_annotation("ls -la\ngrep foo bar.txt", 1, "").?);} test "semantic annotation ignores default last pipe segment" {    try std.testing.expect(semantic_exit_annotation("grep foo bar | wc -l", 1, "") == null);} test "semantic annotation declines short circuit commands" {    try std.testing.expect(semantic_exit_annotation("grep foo bar && echo done", 1, "") == null);} test "semantic annotation declines background commands" {    try std.testing.expect(semantic_exit_annotation("true & grep foo bar", 1, "") == null);} test "semantic annotation ignores quoted pipe" {    try std.testing.expectEqualStrings("note: no matches found", semantic_exit_annotation("grep 'foo|bar' baz", 1, "").?);} test "semantic annotation ignores unknown base command" {    try std.testing.expect(semantic_exit_annotation("python3 myscript.py", 1, "") == null);} test "semantic annotation ignores default nonzero command" {    try std.testing.expect(semantic_exit_annotation("ls -z", 1, "") == null);} test "semantic annotation handles empty and malformed input" {    try std.testing.expect(semantic_exit_annotation("", 1, "") == null);    try std.testing.expect(semantic_exit_annotation("grep 'unterminated", 1, "") == null);}