magellan 3.2.0

Deterministic codebase mapping tool for local development
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

//! Benchmarks for LLM Context API
//!
//! Measures context query latency on large codebases.

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
use magellan::CodeGraph;
use std::path::PathBuf;
use tempfile::TempDir;

/// Benchmark context summary query
fn bench_context_summary(c: &mut Criterion) {
    let (mut graph, _temp_dir) = setup_test_graph();

    c.bench_function("context_summary", |b| {
        b.iter(|| magellan::context::get_project_summary(black_box(&mut graph)))
    });
}

/// Benchmark symbol list query with pagination
fn bench_context_list(c: &mut Criterion) {
    let (mut graph, _temp_dir) = setup_test_graph();

    let page_sizes = [10, 50, 100];
    let mut group = c.benchmark_group("context_list");

    for page_size in page_sizes {
        group.bench_with_input(
            BenchmarkId::from_parameter(page_size),
            &page_size,
            |b, &page_size| {
                b.iter(|| {
                    let query = magellan::context::ListQuery {
                        kind: None,
                        page: Some(1),
                        page_size: Some(page_size),
                        cursor: None,
                        file_pattern: None,
                    };
                    magellan::context::list_symbols(black_box(&mut graph), black_box(&query))
                })
            },
        );
    }
    group.finish();
}

/// Benchmark symbol detail query
fn bench_context_symbol(c: &mut Criterion) {
    let (mut graph, _temp_dir) = setup_test_graph();

    c.bench_function("context_symbol", |b| {
        b.iter(|| {
            magellan::context::get_symbol_detail(
                black_box(&mut graph),
                black_box("main"),
                black_box(None),
            )
        })
    });
}

/// Benchmark file context query
fn bench_context_file(c: &mut Criterion) {
    let (mut graph, _temp_dir) = setup_test_graph();

    c.bench_function("context_file", |b| {
        b.iter(|| {
            magellan::context::get_file_context(black_box(&mut graph), black_box("/test/main.rs"))
        })
    });
}

/// Benchmark with large codebase (100k+ symbols)
fn bench_context_large_codebase(c: &mut Criterion) {
    let (mut graph, _temp_dir) = setup_large_test_graph();

    let mut group = c.benchmark_group("context_large");

    group.bench_function("summary_100k", |b| {
        b.iter(|| magellan::context::get_project_summary(black_box(&mut graph)))
    });

    group.bench_function("list_100k_page1", |b| {
        b.iter(|| {
            let query = magellan::context::ListQuery {
                kind: Some("fn".to_string()),
                page: Some(1),
                page_size: Some(50),
                cursor: None,
                file_pattern: None,
            };
            magellan::context::list_symbols(black_box(&mut graph), black_box(&query))
        })
    });

    group.bench_function("list_100k_page100", |b| {
        b.iter(|| {
            let query = magellan::context::ListQuery {
                kind: Some("fn".to_string()),
                page: Some(100),
                page_size: Some(50),
                cursor: None,
                file_pattern: None,
            };
            magellan::context::list_symbols(black_box(&mut graph), black_box(&query))
        })
    });

    group.finish();
}

/// Set up a test graph with sample data
fn setup_test_graph() -> (CodeGraph, TempDir) {
    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("test.db");

    let mut graph = CodeGraph::open(&db_path).unwrap();

    // Create test files and symbols
    for i in 0..100 {
        let file_path = format!("/test/file_{}.rs", i);
        let _ = graph.delete_file(&file_path);

        for j in 0..10 {
            let symbol_name = format!("function_{}_{}", i, j);
            // Index symbol (simplified - in reality would use index_file)
        }
    }

    (graph, temp_dir)
}

/// Set up a large test graph (100k+ symbols)
fn setup_large_test_graph() -> (CodeGraph, TempDir) {
    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("large.db");

    let mut graph = CodeGraph::open(&db_path).unwrap();

    // Create 1000 files with 100 symbols each = 100k symbols
    for i in 0..1000 {
        let file_path = format!("/test/large/file_{}.rs", i);
        let _ = graph.delete_file(&file_path);

        for j in 0..100 {
            let symbol_name = format!("fn_{}_{}", i, j);
            // Index symbol
        }
    }

    (graph, temp_dir)
}

criterion_group!(
    benches,
    bench_context_summary,
    bench_context_list,
    bench_context_symbol,
    bench_context_file,
    bench_context_large_codebase,
);

criterion_main!(benches);