dapz 0.0.1

AI-friendly DAP compression proxy — token-efficient Debug Adapter Protocol proxy
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

//! Variables response compressor — compress DAP `variables` responses.
//!
//! The `variables` request returns the children of a variable reference.
//! Deeply nested objects can result in very large responses.
//!
//! ## Compression Strategies
//!
//! 1. **Type prefix**: prepend type info before variable name
//! 2. **Value truncation**: truncate long string values
//! 3. **Null removal**: remove variables with `null` value (optional)

use crate::codec::json_rpc::DapMessage;
use crate::error::DapzError;
use crate::interceptors::Interceptor;
use crate::proxy::Direction;

/// Compressor for DAP `variables` responses.
pub struct VariablesCompressor;

#[async_trait::async_trait]
impl Interceptor for VariablesCompressor {
    fn name(&self) -> &str {
        "variables_compressor"
    }

    fn applies_to(&self, msg: &DapMessage, direction: Direction) -> bool {
        direction == Direction::ServerToClient
            && msg.msg_type == "response"
            && msg.command.as_deref() == Some("variables")
    }

    async fn intercept(
        &self,
        mut msg: DapMessage,
        _direction: Direction,
    ) -> Result<Option<DapMessage>, DapzError> {
        if let Some(ref mut body) = msg.body
            && let Some(vars) = body.get_mut("variables").and_then(|v| v.as_array_mut())
        {
            for var in vars.iter_mut() {
                if let Some(value) = var.get("value").and_then(|v| v.as_str()) {
                    let truncated = truncate_value(value);
                    var["value"] = serde_json::Value::String(truncated);
                }
            }
        }
        Ok(Some(msg))
    }
}

/// Truncate long string values for compact display.
fn truncate_value(value: &str) -> String {
    if value.len() > 120 {
        let mut s: String = value.chars().take(120).collect();
        s.push_str("...");
        s
    } else {
        value.to_string()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_truncate_value_short() {
        assert_eq!(truncate_value("hello"), "hello");
    }

    #[test]
    fn test_truncate_value_long() {
        let long = "a".repeat(200);
        let result = truncate_value(&long);
        assert_eq!(result.len(), 123); // 120 + "..."
        assert!(result.ends_with("..."));
    }
}