loregrep 0.6.0

Repository indexing library for AI coding assistants. Tree-sitter parsing, fast in-memory indexing, and tool APIs for LLM integration.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::types::{
    ExportStatement, FunctionCall, FunctionSignature, ImportStatement, StructSignature,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TreeNode {
    pub file_path: String,
    pub language: String,
    pub imports: Vec<ImportStatement>,
    pub exports: Vec<ExportStatement>,
    pub functions: Vec<FunctionSignature>,
    pub structs: Vec<StructSignature>,
    pub function_calls: Vec<FunctionCall>,
    /// Child modules this file declares (Rust `mod x;`, public or private). The
    /// import resolver needs them to tell an in-repo module path from an external
    /// crate: `use config::…` is in-repo only where `mod config;` is declared.
    /// Defaulted on load so caches written before this field stay readable.
    #[serde(default)]
    pub declared_modules: Vec<String>,
    pub content_hash: String,
    pub last_modified: std::time::SystemTime,
    pub parse_errors: Vec<String>,
}

impl TreeNode {
    pub fn new(file_path: String, language: String) -> Self {
        Self {
            file_path,
            language,
            imports: Vec::new(),
            exports: Vec::new(),
            functions: Vec::new(),
            structs: Vec::new(),
            function_calls: Vec::new(),
            declared_modules: Vec::new(),
            content_hash: String::new(),
            last_modified: std::time::SystemTime::now(),
            parse_errors: Vec::new(),
        }
    }

    /// Convert to JSON string for easy display/storage
    pub fn to_json(&self) -> Result<String, serde_json::Error> {
        serde_json::to_string_pretty(self)
    }

    /// Get summary stats for terminal display
    pub fn summary(&self) -> String {
        format!(
            "File: {} | Language: {} | Functions: {} | Structs: {} | Imports: {} | Exports: {}",
            self.file_path,
            self.language,
            self.functions.len(),
            self.structs.len(),
            self.imports.len(),
            self.exports.len()
        )
    }

    /// Get formatted function list for terminal display
    pub fn format_functions(&self) -> Vec<String> {
        self.functions.iter().map(|f| f.format()).collect()
    }

    /// Get formatted struct list for terminal display
    pub fn format_structs(&self) -> Vec<String> {
        self.structs.iter().map(|s| s.format()).collect()
    }

    /// Check if the file has parse errors
    pub fn has_errors(&self) -> bool {
        !self.parse_errors.is_empty()
    }

    /// Add a parse error
    pub fn add_error(&mut self, error: String) {
        self.parse_errors.push(error);
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileAnalysis {
    pub tree_node: TreeNode,
    pub analysis_duration_ms: u64,
    pub success: bool,
}

impl FileAnalysis {
    pub fn new(tree_node: TreeNode, analysis_duration_ms: u64) -> Self {
        Self {
            success: !tree_node.has_errors(),
            tree_node,
            analysis_duration_ms,
        }
    }
}

#[derive(Debug, Clone)]
pub struct PartialAnalysis {
    pub file_path: String,
    pub language: String,
    pub functions: Vec<FunctionSignature>,
    pub structs: Vec<StructSignature>,
    pub imports: Vec<ImportStatement>,
    pub exports: Vec<ExportStatement>,
    pub errors: Vec<String>,
    pub fallback_used: bool,
}

impl PartialAnalysis {
    pub fn new(file_path: String, language: String) -> Self {
        Self {
            file_path,
            language,
            functions: Vec::new(),
            structs: Vec::new(),
            imports: Vec::new(),
            exports: Vec::new(),
            errors: Vec::new(),
            fallback_used: false,
        }
    }

    pub fn with_fallback(mut self) -> Self {
        self.fallback_used = true;
        self
    }

    pub fn add_error(&mut self, error: String) {
        self.errors.push(error);
    }
}