smgrep 0.5.1

Semantic code search tool with GPU acceleration - Rust port of osgrep
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

use std::path::PathBuf;

use serde::{Deserialize, Serialize};
use smallvec::SmallVec;

use crate::{Str, meta::FileHash};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ChunkType {
   Function,
   Class,
   Interface,
   Method,
   TypeAlias,
   Block,
   Other,
}

pub type ContextVec = SmallVec<[Str; 4]>;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Chunk {
   pub content:     Str,
   pub start_line:  usize,
   pub start_col:   usize,
   pub end_line:    usize,
   pub chunk_type:  Option<ChunkType>,
   pub context:     ContextVec,
   pub chunk_index: Option<i32>,
   pub is_anchor:   Option<bool>,
}

impl Chunk {
   pub fn new(
      content: Str,
      start_line: usize,
      end_line: usize,
      chunk_type: ChunkType,
      context: &[Str],
   ) -> Self {
      Self {
         content,
         start_line,
         start_col: 0,
         end_line,
         chunk_type: Some(chunk_type),
         context: context.iter().cloned().collect(),
         chunk_index: None,
         is_anchor: Some(false),
      }
   }

   pub const fn with_col(mut self, col: usize) -> Self {
      self.start_col = col;
      self
   }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PreparedChunk {
   pub id:           String,
   pub path:         PathBuf,
   pub hash:         FileHash,
   pub content:      Str,
   pub start_line:   u32,
   pub end_line:     u32,
   pub chunk_index:  Option<u32>,
   pub is_anchor:    Option<bool>,
   pub chunk_type:   Option<ChunkType>,
   pub context_prev: Option<Str>,
   pub context_next: Option<Str>,
}

#[derive(Debug, Clone)]
pub struct VectorRecord {
   pub id:            String,
   pub path:          PathBuf,
   pub hash:          FileHash,
   pub content:       Str,
   pub start_line:    u32,
   pub end_line:      u32,
   pub chunk_index:   Option<u32>,
   pub is_anchor:     Option<bool>,
   pub chunk_type:    Option<ChunkType>,
   pub context_prev:  Option<Str>,
   pub context_next:  Option<Str>,
   pub vector:        Vec<f32>,
   pub colbert:       Vec<u8>,
   pub colbert_scale: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchResult {
   pub path:       PathBuf,
   pub content:    Str,
   pub score:      f32,
   pub start_line: u32,
   pub num_lines:  u32,
   pub chunk_type: Option<ChunkType>,
   pub is_anchor:  Option<bool>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SearchStatus {
   Ready,
   Indexing,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchResponse {
   pub results:  Vec<SearchResult>,
   pub status:   SearchStatus,
   pub progress: Option<u8>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StoreInfo {
   pub store_id:  String,
   pub row_count: u64,
   pub path:      PathBuf,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncProgress {
   pub processed:    usize,
   pub indexed:      usize,
   pub total:        usize,
   pub current_file: Option<Str>,
}