repopilot 0.10.0

Local-first CLI for repository audit, architecture risk detection, baseline tracking, and CI-friendly code review.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

/// Strips comment content and string literal content from a line using C-style
/// comment syntax (`//` and `/* */`). Characters inside comments or string
/// literals are replaced with spaces so callers can safely match code patterns
/// without false positives from commented-out or stringified code.
///
/// `in_block_comment` must be carried across successive lines; callers own the
/// state and pass a mutable reference for each line in the file.
///
/// Handles mid-line block comments correctly (e.g. `foo(); /* comment */ bar()`).
/// Does not handle Rust raw strings or nested block comments — a future
/// parser-level pass is the right place for those.
pub fn sanitize_c_style(line: &str, in_block_comment: &mut bool) -> String {
    let mut output = String::with_capacity(line.len());
    let mut chars = line.chars().peekable();
    let mut in_string = false;
    let mut in_char = false;
    let mut escaped = false;

    while let Some(ch) = chars.next() {
        if *in_block_comment {
            if ch == '*' && chars.peek() == Some(&'/') {
                chars.next();
                *in_block_comment = false;
                output.push(' ');
                output.push(' ');
            } else {
                output.push(' ');
            }
            continue;
        }

        if in_string {
            if escaped {
                escaped = false;
            } else if ch == '\\' {
                escaped = true;
            } else if ch == '"' {
                in_string = false;
            }
            output.push(' ');
            continue;
        }

        if in_char {
            if escaped {
                escaped = false;
            } else if ch == '\\' {
                escaped = true;
            } else if ch == '\'' {
                in_char = false;
            }
            output.push(' ');
            continue;
        }

        if ch == '/' && chars.peek() == Some(&'/') {
            break;
        }

        if ch == '/' && chars.peek() == Some(&'*') {
            chars.next();
            *in_block_comment = true;
            output.push(' ');
            output.push(' ');
            continue;
        }

        if ch == '"' {
            in_string = true;
            output.push(' ');
            continue;
        }

        if ch == '\'' {
            in_char = true;
            output.push(' ');
            continue;
        }

        output.push(ch);
    }

    output
}

/// Returns `Some(sanitized)` for Python code lines, or `None` if the line
/// is a comment or becomes empty after stripping the `#`-delimited comment
/// portion and string literal contents.
pub fn sanitize_python_line(line: &str) -> Option<String> {
    let trimmed = line.trim();
    if trimmed.is_empty() || trimmed.starts_with('#') {
        return None;
    }
    let code = strip_python_string_literals(line);
    if code.trim().is_empty() {
        None
    } else {
        Some(code)
    }
}

fn strip_python_string_literals(line: &str) -> String {
    let mut result = String::with_capacity(line.len());
    let mut string_delimiter: Option<char> = None;
    let mut escaped = false;

    for ch in line.chars() {
        if let Some(delim) = string_delimiter {
            if escaped {
                escaped = false;
                result.push(' ');
                continue;
            }
            if ch == '\\' {
                escaped = true;
                result.push(' ');
                continue;
            }
            if ch == delim {
                string_delimiter = None;
                result.push(ch);
            } else {
                result.push(' ');
            }
            continue;
        }

        if ch == '#' {
            break;
        }

        if matches!(ch, '"' | '\'') {
            string_delimiter = Some(ch);
            result.push(ch);
        } else {
            result.push(ch);
        }
    }

    result
}