ck_core/
lib.rs

1use serde::{Deserialize, Serialize};
2use std::path::{Path, PathBuf};
3use thiserror::Error;
4
5#[derive(Debug, Error)]
6pub enum CkError {
7    #[error("IO error: {0}")]
8    Io(#[from] std::io::Error),
9
10    #[error("Regex error: {0}")]
11    Regex(#[from] regex::Error),
12
13    #[error("Serialization error: {0}")]
14    Serialization(#[from] bincode::Error),
15
16    #[error("JSON error: {0}")]
17    Json(#[from] serde_json::Error),
18
19    #[error("Index error: {0}")]
20    Index(String),
21
22    #[error("Search error: {0}")]
23    Search(String),
24
25    #[error("Embedding error: {0}")]
26    Embedding(String),
27
28    #[error("Other error: {0}")]
29    Other(String),
30}
31
32pub type Result<T> = std::result::Result<T, CkError>;
33
34#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
35pub enum Language {
36    Rust,
37    Python,
38    JavaScript,
39    TypeScript,
40    Haskell,
41    Go,
42    Java,
43    C,
44    Cpp,
45    CSharp,
46    Ruby,
47    Php,
48    Swift,
49    Kotlin,
50}
51
52impl Language {
53    pub fn from_extension(ext: &str) -> Option<Self> {
54        match ext {
55            "rs" => Some(Language::Rust),
56            "py" => Some(Language::Python),
57            "js" => Some(Language::JavaScript),
58            "ts" | "tsx" => Some(Language::TypeScript),
59            "hs" | "lhs" => Some(Language::Haskell),
60            "go" => Some(Language::Go),
61            "java" => Some(Language::Java),
62            "c" => Some(Language::C),
63            "cpp" | "cc" | "cxx" | "c++" => Some(Language::Cpp),
64            "h" | "hpp" => Some(Language::Cpp), // Assume C++ for headers
65            "cs" => Some(Language::CSharp),
66            "rb" => Some(Language::Ruby),
67            "php" => Some(Language::Php),
68            "swift" => Some(Language::Swift),
69            "kt" | "kts" => Some(Language::Kotlin),
70            _ => None,
71        }
72    }
73
74    pub fn from_path(path: &Path) -> Option<Self> {
75        path.extension()
76            .and_then(|ext| ext.to_str())
77            .and_then(Self::from_extension)
78    }
79}
80
81impl std::fmt::Display for Language {
82    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
83        let name = match self {
84            Language::Rust => "rust",
85            Language::Python => "python",
86            Language::JavaScript => "javascript",
87            Language::TypeScript => "typescript",
88            Language::Haskell => "haskell",
89            Language::Go => "go",
90            Language::Java => "java",
91            Language::C => "c",
92            Language::Cpp => "cpp",
93            Language::CSharp => "csharp",
94            Language::Ruby => "ruby",
95            Language::Php => "php",
96            Language::Swift => "swift",
97            Language::Kotlin => "kotlin",
98        };
99        write!(f, "{}", name)
100    }
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize)]
104pub struct Span {
105    pub byte_start: usize,
106    pub byte_end: usize,
107    pub line_start: usize,
108    pub line_end: usize,
109}
110
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct FileMetadata {
113    pub path: PathBuf,
114    pub hash: String,
115    pub last_modified: u64,
116    pub size: u64,
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize)]
120pub struct SearchResult {
121    pub file: PathBuf,
122    pub span: Span,
123    pub score: f32,
124    pub preview: String,
125    #[serde(skip_serializing_if = "Option::is_none")]
126    pub lang: Option<Language>,
127    #[serde(skip_serializing_if = "Option::is_none")]
128    pub symbol: Option<String>,
129    #[serde(skip_serializing_if = "Option::is_none")]
130    pub chunk_hash: Option<String>,
131    #[serde(skip_serializing_if = "Option::is_none")]
132    pub index_epoch: Option<u64>,
133}
134
135#[derive(Debug, Clone, Serialize, Deserialize)]
136pub struct JsonSearchResult {
137    pub file: String,
138    pub span: Span,
139    pub lang: Option<Language>,
140    pub symbol: Option<String>,
141    pub score: f32,
142    pub signals: SearchSignals,
143    pub preview: String,
144    pub model: String,
145}
146
147#[derive(Debug, Clone, Serialize, Deserialize)]
148pub struct JsonlSearchResult {
149    pub path: String,
150    pub span: Span,
151    pub language: Option<String>,
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub snippet: Option<String>,
154    #[serde(skip_serializing_if = "Option::is_none")]
155    pub score: Option<f32>,
156    #[serde(skip_serializing_if = "Option::is_none")]
157    pub chunk_hash: Option<String>,
158    #[serde(skip_serializing_if = "Option::is_none")]
159    pub index_epoch: Option<u64>,
160}
161
162#[derive(Debug, Clone, Serialize, Deserialize)]
163pub struct SearchSignals {
164    pub lex_rank: Option<usize>,
165    pub vec_rank: Option<usize>,
166    pub rrf_score: f32,
167}
168
169#[derive(Debug, Clone, PartialEq)]
170pub enum SearchMode {
171    Regex,
172    Lexical,
173    Semantic,
174    Hybrid,
175}
176
177#[derive(Debug, Clone)]
178pub struct SearchOptions {
179    pub mode: SearchMode,
180    pub query: String,
181    pub path: PathBuf,
182    pub top_k: Option<usize>,
183    pub threshold: Option<f32>,
184    pub case_insensitive: bool,
185    pub whole_word: bool,
186    pub fixed_string: bool,
187    pub line_numbers: bool,
188    pub context_lines: usize,
189    pub before_context_lines: usize,
190    pub after_context_lines: usize,
191    pub recursive: bool,
192    pub json_output: bool,
193    pub jsonl_output: bool,
194    pub no_snippet: bool,
195    pub reindex: bool,
196    pub show_scores: bool,
197    pub show_filenames: bool,
198    pub files_with_matches: bool,
199    pub files_without_matches: bool,
200    pub exclude_patterns: Vec<String>,
201    pub respect_gitignore: bool,
202    pub full_section: bool,
203    // Enhanced embedding options (search-time only)
204    pub rerank: bool,
205    pub rerank_model: Option<String>,
206}
207
208impl JsonlSearchResult {
209    pub fn from_search_result(result: &SearchResult, include_snippet: bool) -> Self {
210        Self {
211            path: result.file.to_string_lossy().to_string(),
212            span: result.span.clone(),
213            language: result.lang.as_ref().map(|l| l.to_string()),
214            snippet: if include_snippet {
215                Some(result.preview.clone())
216            } else {
217                None
218            },
219            score: if result.score >= 0.0 {
220                Some(result.score)
221            } else {
222                None
223            },
224            chunk_hash: result.chunk_hash.clone(),
225            index_epoch: result.index_epoch,
226        }
227    }
228}
229
230impl Default for SearchOptions {
231    fn default() -> Self {
232        Self {
233            mode: SearchMode::Regex,
234            query: String::new(),
235            path: PathBuf::from("."),
236            top_k: None,
237            threshold: None,
238            case_insensitive: false,
239            whole_word: false,
240            fixed_string: false,
241            line_numbers: false,
242            context_lines: 0,
243            before_context_lines: 0,
244            after_context_lines: 0,
245            recursive: true,
246            json_output: false,
247            jsonl_output: false,
248            no_snippet: false,
249            reindex: false,
250            show_scores: false,
251            show_filenames: false,
252            files_with_matches: false,
253            files_without_matches: false,
254            exclude_patterns: get_default_exclude_patterns(),
255            respect_gitignore: true,
256            full_section: false,
257            // Enhanced embedding options (search-time only)
258            rerank: false,
259            rerank_model: None,
260        }
261    }
262}
263
264/// Get default exclusion patterns for directories that should be skipped during search.
265/// These are common cache, build, and system directories that rarely contain user code.
266pub fn get_default_exclude_patterns() -> Vec<String> {
267    vec![
268        // ck's own index directory
269        ".ck".to_string(),
270        // AI/ML model cache directories
271        ".fastembed_cache".to_string(),
272        ".cache".to_string(),
273        "__pycache__".to_string(),
274        // Version control
275        ".git".to_string(),
276        ".svn".to_string(),
277        ".hg".to_string(),
278        // Build directories
279        "target".to_string(),       // Rust
280        "build".to_string(),        // Various
281        "dist".to_string(),         // JavaScript/Python
282        "node_modules".to_string(), // JavaScript
283        ".gradle".to_string(),      // Java
284        ".mvn".to_string(),         // Maven
285        "bin".to_string(),          // Various
286        "obj".to_string(),          // .NET
287        // Python virtual environments
288        "venv".to_string(),
289        ".venv".to_string(),
290        "env".to_string(),
291        ".env".to_string(),
292        "virtualenv".to_string(),
293        // IDE/Editor directories
294        ".vscode".to_string(),
295        ".idea".to_string(),
296        ".eclipse".to_string(),
297        // Temporary directories
298        "tmp".to_string(),
299        "temp".to_string(),
300        ".tmp".to_string(),
301    ]
302}
303
304pub fn get_sidecar_path(repo_root: &Path, file_path: &Path) -> PathBuf {
305    let relative = file_path.strip_prefix(repo_root).unwrap_or(file_path);
306    let mut sidecar = repo_root.join(".ck");
307    sidecar.push(relative);
308    let ext = relative
309        .extension()
310        .map(|e| format!("{}.ck", e.to_string_lossy()))
311        .unwrap_or_else(|| "ck".to_string());
312    sidecar.set_extension(ext);
313    sidecar
314}
315
316pub fn compute_file_hash(path: &Path) -> Result<String> {
317    let data = std::fs::read(path)?;
318    let hash = blake3::hash(&data);
319    Ok(hash.to_hex().to_string())
320}
321
322#[cfg(test)]
323mod tests {
324    use super::*;
325    use std::fs;
326    use tempfile::TempDir;
327
328    #[test]
329    fn test_span_creation() {
330        let span = Span {
331            byte_start: 0,
332            byte_end: 10,
333            line_start: 1,
334            line_end: 2,
335        };
336
337        assert_eq!(span.byte_start, 0);
338        assert_eq!(span.byte_end, 10);
339        assert_eq!(span.line_start, 1);
340        assert_eq!(span.line_end, 2);
341    }
342
343    #[test]
344    fn test_search_options_default() {
345        let options = SearchOptions::default();
346        assert!(matches!(options.mode, SearchMode::Regex));
347        assert_eq!(options.query, "");
348        assert_eq!(options.path, PathBuf::from("."));
349        assert_eq!(options.top_k, None);
350        assert_eq!(options.threshold, None);
351        assert!(!options.case_insensitive);
352        assert!(!options.whole_word);
353        assert!(!options.fixed_string);
354        assert!(!options.line_numbers);
355        assert_eq!(options.context_lines, 0);
356        assert!(options.recursive);
357        assert!(!options.json_output);
358        assert!(!options.reindex);
359        assert!(!options.show_scores);
360        assert!(!options.show_filenames);
361    }
362
363    #[test]
364    fn test_file_metadata_serialization() {
365        let metadata = FileMetadata {
366            path: PathBuf::from("test.txt"),
367            hash: "abc123".to_string(),
368            last_modified: 1234567890,
369            size: 1024,
370        };
371
372        let json = serde_json::to_string(&metadata).unwrap();
373        let deserialized: FileMetadata = serde_json::from_str(&json).unwrap();
374
375        assert_eq!(metadata.path, deserialized.path);
376        assert_eq!(metadata.hash, deserialized.hash);
377        assert_eq!(metadata.last_modified, deserialized.last_modified);
378        assert_eq!(metadata.size, deserialized.size);
379    }
380
381    #[test]
382    fn test_search_result_serialization() {
383        let result = SearchResult {
384            file: PathBuf::from("test.txt"),
385            span: Span {
386                byte_start: 0,
387                byte_end: 10,
388                line_start: 1,
389                line_end: 1,
390            },
391            score: 0.95,
392            preview: "hello world".to_string(),
393            lang: Some(Language::Rust),
394            symbol: Some("main".to_string()),
395            chunk_hash: Some("abc123".to_string()),
396            index_epoch: Some(1699123456),
397        };
398
399        let json = serde_json::to_string(&result).unwrap();
400        let deserialized: SearchResult = serde_json::from_str(&json).unwrap();
401
402        assert_eq!(result.file, deserialized.file);
403        assert_eq!(result.score, deserialized.score);
404        assert_eq!(result.preview, deserialized.preview);
405        assert_eq!(result.lang, deserialized.lang);
406        assert_eq!(result.symbol, deserialized.symbol);
407        assert_eq!(result.chunk_hash, deserialized.chunk_hash);
408        assert_eq!(result.index_epoch, deserialized.index_epoch);
409    }
410
411    #[test]
412    fn test_jsonl_search_result_conversion() {
413        let result = SearchResult {
414            file: PathBuf::from("src/auth.rs"),
415            span: Span {
416                byte_start: 1203,
417                byte_end: 1456,
418                line_start: 42,
419                line_end: 58,
420            },
421            score: 0.89,
422            preview: "function authenticate(user) {...}".to_string(),
423            lang: Some(Language::Rust),
424            symbol: Some("authenticate".to_string()),
425            chunk_hash: Some("abc123def456".to_string()),
426            index_epoch: Some(1699123456),
427        };
428
429        // Test with snippet
430        let jsonl_with_snippet = JsonlSearchResult::from_search_result(&result, true);
431        assert_eq!(jsonl_with_snippet.path, "src/auth.rs");
432        assert_eq!(jsonl_with_snippet.span.line_start, 42);
433        assert_eq!(jsonl_with_snippet.language, Some("rust".to_string()));
434        assert_eq!(
435            jsonl_with_snippet.snippet,
436            Some("function authenticate(user) {...}".to_string())
437        );
438        assert_eq!(jsonl_with_snippet.score, Some(0.89));
439        assert_eq!(
440            jsonl_with_snippet.chunk_hash,
441            Some("abc123def456".to_string())
442        );
443        assert_eq!(jsonl_with_snippet.index_epoch, Some(1699123456));
444
445        // Test without snippet
446        let jsonl_no_snippet = JsonlSearchResult::from_search_result(&result, false);
447        assert_eq!(jsonl_no_snippet.snippet, None);
448        assert_eq!(jsonl_no_snippet.path, "src/auth.rs");
449    }
450
451    #[test]
452    fn test_get_sidecar_path() {
453        let repo_root = PathBuf::from("/home/user/project");
454        let file_path = PathBuf::from("/home/user/project/src/main.rs");
455
456        let sidecar = get_sidecar_path(&repo_root, &file_path);
457        let expected = PathBuf::from("/home/user/project/.ck/src/main.rs.ck");
458
459        assert_eq!(sidecar, expected);
460    }
461
462    #[test]
463    fn test_get_sidecar_path_no_extension() {
464        let repo_root = PathBuf::from("/project");
465        let file_path = PathBuf::from("/project/README");
466
467        let sidecar = get_sidecar_path(&repo_root, &file_path);
468        let expected = PathBuf::from("/project/.ck/README.ck");
469
470        assert_eq!(sidecar, expected);
471    }
472
473    #[test]
474    fn test_compute_file_hash() {
475        let temp_dir = TempDir::new().unwrap();
476        let file_path = temp_dir.path().join("test.txt");
477
478        fs::write(&file_path, "hello world").unwrap();
479
480        let hash1 = compute_file_hash(&file_path).unwrap();
481        let hash2 = compute_file_hash(&file_path).unwrap();
482
483        // Same content should produce same hash
484        assert_eq!(hash1, hash2);
485        assert!(!hash1.is_empty());
486
487        // Different content should produce different hash
488        fs::write(&file_path, "hello rust").unwrap();
489        let hash3 = compute_file_hash(&file_path).unwrap();
490        assert_ne!(hash1, hash3);
491    }
492
493    #[test]
494    fn test_compute_file_hash_nonexistent() {
495        let result = compute_file_hash(&PathBuf::from("nonexistent.txt"));
496        assert!(result.is_err());
497    }
498
499    #[test]
500    fn test_json_search_result_serialization() {
501        let signals = SearchSignals {
502            lex_rank: Some(1),
503            vec_rank: Some(2),
504            rrf_score: 0.85,
505        };
506
507        let result = JsonSearchResult {
508            file: "test.txt".to_string(),
509            span: Span {
510                byte_start: 0,
511                byte_end: 5,
512                line_start: 1,
513                line_end: 1,
514            },
515            lang: None, // txt is not a supported language
516            symbol: None,
517            score: 0.95,
518            signals,
519            preview: "hello".to_string(),
520            model: "bge-small".to_string(),
521        };
522
523        let json = serde_json::to_string(&result).unwrap();
524        let deserialized: JsonSearchResult = serde_json::from_str(&json).unwrap();
525
526        assert_eq!(result.file, deserialized.file);
527        assert_eq!(result.score, deserialized.score);
528        assert_eq!(result.signals.rrf_score, deserialized.signals.rrf_score);
529        assert_eq!(result.model, deserialized.model);
530    }
531
532    #[test]
533    fn test_language_from_extension() {
534        assert_eq!(Language::from_extension("rs"), Some(Language::Rust));
535        assert_eq!(Language::from_extension("py"), Some(Language::Python));
536        assert_eq!(Language::from_extension("js"), Some(Language::JavaScript));
537        assert_eq!(Language::from_extension("ts"), Some(Language::TypeScript));
538        assert_eq!(Language::from_extension("tsx"), Some(Language::TypeScript));
539        assert_eq!(Language::from_extension("hs"), Some(Language::Haskell));
540        assert_eq!(Language::from_extension("lhs"), Some(Language::Haskell));
541        assert_eq!(Language::from_extension("go"), Some(Language::Go));
542        assert_eq!(Language::from_extension("java"), Some(Language::Java));
543        assert_eq!(Language::from_extension("c"), Some(Language::C));
544        assert_eq!(Language::from_extension("cpp"), Some(Language::Cpp));
545        assert_eq!(Language::from_extension("cs"), Some(Language::CSharp));
546        assert_eq!(Language::from_extension("rb"), Some(Language::Ruby));
547        assert_eq!(Language::from_extension("php"), Some(Language::Php));
548        assert_eq!(Language::from_extension("swift"), Some(Language::Swift));
549        assert_eq!(Language::from_extension("kt"), Some(Language::Kotlin));
550        assert_eq!(Language::from_extension("kts"), Some(Language::Kotlin));
551        assert_eq!(Language::from_extension("unknown"), None);
552    }
553
554    #[test]
555    fn test_language_from_path() {
556        assert_eq!(
557            Language::from_path(&PathBuf::from("test.rs")),
558            Some(Language::Rust)
559        );
560        assert_eq!(
561            Language::from_path(&PathBuf::from("test.py")),
562            Some(Language::Python)
563        );
564        assert_eq!(
565            Language::from_path(&PathBuf::from("test.js")),
566            Some(Language::JavaScript)
567        );
568        assert_eq!(
569            Language::from_path(&PathBuf::from("test.hs")),
570            Some(Language::Haskell)
571        );
572        assert_eq!(
573            Language::from_path(&PathBuf::from("test.lhs")),
574            Some(Language::Haskell)
575        );
576        assert_eq!(
577            Language::from_path(&PathBuf::from("test.go")),
578            Some(Language::Go)
579        );
580        assert_eq!(Language::from_path(&PathBuf::from("test.unknown")), None); // unknown extensions return None
581        assert_eq!(Language::from_path(&PathBuf::from("noext")), None); // no extension
582    }
583
584    #[test]
585    fn test_language_display() {
586        assert_eq!(Language::Rust.to_string(), "rust");
587        assert_eq!(Language::Python.to_string(), "python");
588        assert_eq!(Language::JavaScript.to_string(), "javascript");
589        assert_eq!(Language::TypeScript.to_string(), "typescript");
590        assert_eq!(Language::Go.to_string(), "go");
591        assert_eq!(Language::Java.to_string(), "java");
592    }
593}
ck_core/lib.rs

ck_core/
lib.rs
