vv-agent 0.2.0

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
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

use std::path::Path;

use serde_json::Value;

use crate::tools::base::ToolContext;
use crate::tools::common::{matches_file_type, workspace_relative_path_or_absolute};

use super::decode::decode_rg_field;
use super::paths::normalize_rg_relative_path;

pub(super) enum RgJsonEvent {
    Begin {
        path: String,
    },
    Match {
        path: String,
        line_number: u64,
        matched_lines: String,
        submatches: Vec<RgSubmatch>,
    },
    Context {
        path: String,
        line_number: u64,
        lines: String,
    },
}

pub(super) struct RgSubmatch {
    pub start: Option<usize>,
    pub end: Option<usize>,
    pub matched_text: String,
}

impl RgJsonEvent {
    pub fn from_value(
        context: &ToolContext,
        base_path: &Path,
        file_type: Option<&str>,
        event: &Value,
    ) -> Option<Self> {
        let event_type = event
            .get("type")
            .and_then(Value::as_str)
            .unwrap_or_default();
        if event_type == "summary" {
            return None;
        }
        let data = event.get("data").and_then(Value::as_object)?;
        let path = event_workspace_path(context, base_path, file_type, data.get("path"))?;
        match event_type {
            "begin" => Some(Self::Begin { path }),
            "match" => Some(Self::Match {
                path,
                line_number: data.get("line_number").and_then(Value::as_u64).unwrap_or(1),
                matched_lines: decode_rg_field(data.get("lines")),
                submatches: parse_submatches(data.get("submatches")),
            }),
            "context" => {
                let line_number = data.get("line_number").and_then(Value::as_u64)?;
                Some(Self::Context {
                    path,
                    line_number,
                    lines: decode_rg_field(data.get("lines")),
                })
            }
            _ => None,
        }
    }
}

fn event_workspace_path(
    context: &ToolContext,
    base_path: &Path,
    file_type: Option<&str>,
    path_field: Option<&Value>,
) -> Option<String> {
    let rel_from_base = decode_rg_field(path_field);
    if rel_from_base.is_empty() {
        return None;
    }
    let normalized = normalize_rg_relative_path(&rel_from_base);
    let rel_workspace =
        workspace_relative_path_or_absolute(&context.workspace, &base_path.join(normalized));
    if let Some(file_type) = file_type {
        if !matches_file_type(&rel_workspace, Some(file_type)) {
            return None;
        }
    }
    Some(rel_workspace)
}

fn parse_submatches(value: Option<&Value>) -> Vec<RgSubmatch> {
    value
        .and_then(Value::as_array)
        .map(|items| items.iter().filter_map(parse_submatch).collect())
        .unwrap_or_default()
}

fn parse_submatch(value: &Value) -> Option<RgSubmatch> {
    let object = value.as_object()?;
    Some(RgSubmatch {
        start: object
            .get("start")
            .and_then(Value::as_u64)
            .map(|value| value as usize),
        end: object
            .get("end")
            .and_then(Value::as_u64)
            .map(|value| value as usize),
        matched_text: decode_rg_field(object.get("match")),
    })
}