vv-agent 0.4.8

VectorVein agent runtime, SDK, CLI, tools, and workspace backends
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

use std::collections::BTreeMap;

use regex::Regex;
use serde_json::{json, Value};

#[derive(Clone, Copy)]
pub(crate) struct GrepTextOptions {
    pub(crate) multiline: bool,
    pub(crate) before_context: usize,
    pub(crate) after_context: usize,
    pub(crate) show_line_numbers: bool,
}

pub(crate) struct GrepTextResult {
    pub(crate) rows: Vec<Value>,
    pub(crate) match_count: usize,
}

pub(crate) fn grep_text(
    relative_path: &str,
    text: &str,
    regex: &Regex,
    options: GrepTextOptions,
) -> GrepTextResult {
    if options.multiline {
        let rows = regex
            .find_iter(text)
            .map(|matched| {
                let line = text[..matched.start()]
                    .chars()
                    .filter(|ch| *ch == '\n')
                    .count()
                    + 1;
                json!({
                    "path": relative_path,
                    "line": line,
                    "text": matched.as_str(),
                    "is_match": true,
                })
            })
            .collect::<Vec<_>>();
        return GrepTextResult {
            match_count: rows.len(),
            rows,
        };
    }

    let lines = text.lines().collect::<Vec<_>>();
    let mut include_lines = BTreeMap::<usize, bool>::new();
    let mut match_count = 0usize;
    for (index, line) in lines.iter().enumerate() {
        let line_match_count = regex.find_iter(line).count();
        if line_match_count == 0 {
            continue;
        }
        match_count += line_match_count;
        let start = index.saturating_sub(options.before_context);
        let end = (index + options.after_context).min(lines.len().saturating_sub(1));
        for row_index in start..=end {
            include_lines.entry(row_index).or_insert(false);
        }
        include_lines.insert(index, true);
    }

    let rows = include_lines
        .into_iter()
        .map(|(index, is_match)| {
            let line_number = index + 1;
            let mut row = json!({
                "path": relative_path,
                "line": line_number,
                "text": lines[index],
                "is_match": is_match,
            });
            if !options.show_line_numbers {
                row.as_object_mut().expect("row object").remove("line");
            }
            row
        })
        .collect();
    GrepTextResult { rows, match_count }
}