loregrep 0.5.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

#!/usr/bin/env python3
"""
Dependency Analysis Example - Understanding Import/Export Relationships

Demonstrates the get_dependencies and find_callers tools for analyzing
how code modules interact and depend on each other.
"""

import asyncio
import json
from pathlib import Path
import loregrep


async def main():
    print("🔗 Dependency Analysis Example")
    print("=" * 35)
    
    try:
        # Create LoreGrep instance
        lg = loregrep.LoreGrep.polyglot_project(".")
        print("✅ LoreGrep instance created")
        
        # Scan repository
        print("\n📁 Scanning repository...")
        scan_result = await lg.scan(".")
        print(f"✅ Scanned {scan_result.files_scanned} files")
        
        # Find source files to analyze
        source_files = []
        for pattern in ["*.py", "*.rs", "*.js", "*.ts"]:
            source_files.extend(Path(".").glob(f"**/{pattern}"))
        
        if not source_files:
            print("⚠️  No source files found")
            return
        
        # Analyze dependencies for a few files
        files_to_analyze = source_files[:3]
        
        for file_path in files_to_analyze:
            print(f"\n📄 Analyzing dependencies for {file_path.name}...")
            
            try:
                dep_result = await lg.execute_tool("get_dependencies", {
                    "file_path": str(file_path)
                })
                
                # Parse dependency results
                try:
                    data = json.loads(dep_result.content)
                    
                    imports = data.get("imports", [])
                    exports = data.get("exports", [])
                    
                    if imports:
                        print(f"   📥 Imports ({len(imports)}):")
                        for imp in imports[:5]:  # Show first 5
                            module = imp.get("module", "unknown")
                            import_type = imp.get("type", "unknown")
                            print(f"      • {module} ({import_type})")
                        if len(imports) > 5:
                            print(f"      ... and {len(imports) - 5} more")
                    
                    if exports:
                        print(f"   📤 Exports ({len(exports)}):")
                        for exp in exports[:5]:  # Show first 5
                            name = exp.get("name", "unknown")
                            export_type = exp.get("type", "unknown")
                            print(f"      • {name} ({export_type})")
                        if len(exports) > 5:
                            print(f"      ... and {len(exports) - 5} more")
                    
                    if not imports and not exports:
                        print(f"   ⚪ No dependencies found")
                        
                except json.JSONDecodeError:
                    print(f"   ✅ Dependencies analyzed: {len(dep_result.content)} characters")
                    
            except Exception as e:
                print(f"   ❌ Dependency analysis failed: {e}")
        
        # Demonstrate caller analysis
        print(f"\n📞 Finding function callers...")
        common_functions = ["main", "new", "init", "create", "load"]
        
        for func_name in common_functions:
            try:
                caller_result = await lg.execute_tool("find_callers", {
                    "function_name": func_name
                })
                
                try:
                    data = json.loads(caller_result.content)
                    callers = data.get("callers", [])
                    
                    if callers:
                        print(f"   📞 '{func_name}' called from {len(callers)} locations:")
                        for caller in callers[:3]:  # Show first 3
                            file_path = caller.get("file_path", "unknown")
                            line = caller.get("line_number", "?")
                            print(f"      • {Path(file_path).name}:{line}")
                        if len(callers) > 3:
                            print(f"      ... and {len(callers) - 3} more locations")
                        break  # Found some callers, stop here
                        
                except json.JSONDecodeError:
                    pass
                    
            except Exception:
                pass  # Try next function
        
        print(f"\n💡 Dependency analysis helps understand code relationships and architecture")
        
    except ImportError:
        print("❌ LoreGrep not installed. Run: maturin develop --features python")
    except Exception as e:
        print(f"❌ Error: {e}")


if __name__ == "__main__":
    asyncio.run(main())