llm 1.3.8

A Rust library unifying multiple LLM 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
113
114
115
116

//! Indentation-aware file reading.

use std::collections::VecDeque;
use std::path::Path;

use crate::tools::error::ToolError;

use super::types::{format_line, measure_indent, IndentationArgs, LineRecord, TAB_WIDTH};

/// Read with indentation-aware block extraction.
pub fn read_indentation(
    path: &Path,
    offset: usize,
    limit: usize,
    opts: IndentationArgs,
) -> Result<Vec<String>, ToolError> {
    let content = std::fs::read_to_string(path).map_err(|e| ToolError::Execution(e.to_string()))?;

    let lines: Vec<LineRecord> = content
        .lines()
        .enumerate()
        .map(|(i, line)| LineRecord {
            number: i + 1,
            raw: line.to_string(),
            indent: measure_indent(line),
        })
        .collect();

    if lines.is_empty() {
        return Ok(Vec::new());
    }

    let anchor_line = opts.anchor_line.unwrap_or(offset);
    if anchor_line == 0 || anchor_line > lines.len() {
        return Err(ToolError::RespondToModel(
            "anchor_line exceeds file length".to_string(),
        ));
    }

    let anchor_index = anchor_line - 1;
    let effective_indents = compute_effective_indents(&lines);
    let anchor_indent = effective_indents[anchor_index];

    let min_indent = if opts.max_levels == 0 {
        0
    } else {
        anchor_indent.saturating_sub(opts.max_levels * TAB_WIDTH)
    };

    let final_limit = limit.min(opts.max_lines.unwrap_or(limit)).min(lines.len());
    if final_limit == 1 {
        return Ok(vec![format_line(&lines[anchor_index])]);
    }

    let mut out: VecDeque<&LineRecord> = VecDeque::with_capacity(limit);
    out.push_back(&lines[anchor_index]);

    let mut i: isize = anchor_index as isize - 1;
    let mut j: usize = anchor_index + 1;

    while out.len() < final_limit {
        let mut progressed = false;

        // Expand upward
        if i >= 0 {
            let iu = i as usize;
            if effective_indents[iu] >= min_indent {
                out.push_front(&lines[iu]);
                progressed = true;
                i -= 1;
            } else {
                i = -1;
            }
        }

        // Expand downward
        if j < lines.len() && out.len() < final_limit {
            if effective_indents[j] >= min_indent {
                out.push_back(&lines[j]);
                progressed = true;
                j += 1;
            } else {
                j = lines.len();
            }
        }

        if !progressed {
            break;
        }
    }

    // Trim empty lines at boundaries
    while out.front().is_some_and(|l| l.raw.trim().is_empty()) {
        out.pop_front();
    }
    while out.back().is_some_and(|l| l.raw.trim().is_empty()) {
        out.pop_back();
    }

    Ok(out.iter().map(|r| format_line(r)).collect())
}

/// Compute effective indentation levels, carrying forward for blank lines.
fn compute_effective_indents(records: &[LineRecord]) -> Vec<usize> {
    let mut effective = Vec::with_capacity(records.len());
    let mut prev = 0;
    for record in records {
        if record.raw.trim().is_empty() {
            effective.push(prev);
        } else {
            prev = record.indent;
            effective.push(prev);
        }
    }
    effective
}