ctxpack 0.1.0

Configuration-driven source packing for LLM context, with a versioning protocol for incremental patch/replace
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

use anyhow::Result;

use super::{ExtractionResult, Fragment};

#[derive(Debug, Clone)]
struct LineRange {
    start: u32,
    end: Option<u32>,
}

fn parse_ranges(ranges: &str) -> Result<Vec<LineRange>> {
    let mut result = Vec::new();
    for part in ranges.split(',') {
        let part = part.trim();
        if part.is_empty() {
            continue;
        }
        if let Some(dash_pos) = part.find('-') {
            let start_str = &part[..dash_pos];
            let end_str = &part[dash_pos + 1..];
            let start: u32 = start_str
                .trim()
                .parse()
                .map_err(|_| anyhow::anyhow!("invalid line range start: {}", start_str))?;
            let end = if end_str.trim().is_empty() {
                None
            } else {
                Some(
                    end_str
                        .trim()
                        .parse::<u32>()
                        .map_err(|_| anyhow::anyhow!("invalid line range end: {}", end_str))?,
                )
            };
            result.push(LineRange { start, end });
        } else {
            let n: u32 =
                part.parse().map_err(|_| anyhow::anyhow!("invalid line number: {}", part))?;
            result.push(LineRange { start: n, end: Some(n) });
        }
    }
    Ok(result)
}

pub fn extract_lines(content: &str, ranges: &str) -> Result<ExtractionResult> {
    let all_lines: Vec<&str> = content.lines().collect();
    let total_lines = all_lines.len() as u32;

    let parsed_ranges = parse_ranges(ranges)?;
    let mut fragments = Vec::new();

    for range in &parsed_ranges {
        let start = range.start.max(1);
        let end = range.end.unwrap_or(total_lines).min(total_lines);
        if start > total_lines || start > end {
            continue;
        }
        let mut frag_content = join_lines(&all_lines[(start - 1) as usize..end as usize]);
        if content.ends_with('\n') || range.end.is_none() {
            frag_content.push('\n');
        }
        fragments.push(Fragment { line_start: start, line_end: end, content: frag_content });
    }

    let covers_all = parsed_ranges.len() == 1
        && parsed_ranges[0].start == 1
        && parsed_ranges[0].end.map(|e| e >= total_lines).unwrap_or(true);

    Ok(ExtractionResult { fragments, total_lines, is_partial: !covers_all })
}

fn join_lines(lines: &[&str]) -> String {
    let len = lines.iter().map(|line| line.len()).sum::<usize>() + lines.len().saturating_sub(1);
    let mut out = String::with_capacity(len);
    for (i, line) in lines.iter().enumerate() {
        if i > 0 {
            out.push('\n');
        }
        out.push_str(line);
    }
    out
}

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

    fn make_content(n: u32) -> String {
        (1..=n).map(|i| format!("line{}", i)).collect::<Vec<_>>().join("\n") + "\n"
    }

    #[test]
    fn test_lines_1_5() {
        let content = make_content(10);
        let result = extract_lines(&content, "1-5").unwrap();
        assert_eq!(result.fragments.len(), 1);
        assert_eq!(result.fragments[0].line_start, 1);
        assert_eq!(result.fragments[0].line_end, 5);
        assert!(result.is_partial);
    }

    #[test]
    fn test_lines_two_ranges() {
        let content = make_content(10);
        let result = extract_lines(&content, "3-5,8-10").unwrap();
        assert_eq!(result.fragments.len(), 2);
        assert_eq!(result.fragments[0].line_start, 3);
        assert_eq!(result.fragments[0].line_end, 5);
        assert_eq!(result.fragments[1].line_start, 8);
        assert_eq!(result.fragments[1].line_end, 10);
    }

    #[test]
    fn test_lines_to_end() {
        let content = make_content(10);
        let result = extract_lines(&content, "5-").unwrap();
        assert_eq!(result.fragments.len(), 1);
        assert_eq!(result.fragments[0].line_start, 5);
        assert_eq!(result.fragments[0].line_end, 10);
    }

    #[test]
    fn test_parse_single_line() {
        let content = make_content(10);
        let result = extract_lines(&content, "3").unwrap();
        assert_eq!(result.fragments.len(), 1);
        assert_eq!(result.fragments[0].line_start, 3);
        assert_eq!(result.fragments[0].line_end, 3);
    }
}