e1c8d98bf2
* add llamacpp plugin * Refactor llamacpp plugin * add utils plugin * remove utils folder * add hardware implementation * add utils folder + move utils function * organize cargo files * refactor utils src * refactor util * apply fmt * fmt * Update gguf + reformat * add permission for gguf commands * fix cargo test windows * revert yarn lock * remove cargo.lock for hardware plugin * ignore cargo.lock file * Fix hardware invoke + refactor hardware + refactor tests, constants * use api wrapper in extension to invoke hardware call + api wrapper build integration * add newline at EOF (per Akarshan) * add vi mock for getSystemInfo
76 lines
2.4 KiB
Rust
76 lines
2.4 KiB
Rust
/// Parses 16-byte array to UUID string format
|
|
pub fn parse_uuid(bytes: &[u8; 16]) -> String {
|
|
// UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
|
|
// 4-2-2-2-6 bytes
|
|
format!(
|
|
"{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
|
|
bytes[0], bytes[1], bytes[2], bytes[3],
|
|
bytes[4], bytes[5],
|
|
bytes[6], bytes[7],
|
|
bytes[8], bytes[9],
|
|
bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]
|
|
)
|
|
}
|
|
|
|
/// Safely converts C string buffer to Rust String
|
|
pub fn parse_c_string(buf: &[i8]) -> String {
|
|
let bytes: Vec<u8> = buf
|
|
.iter()
|
|
.take_while(|&&c| c != 0)
|
|
.map(|&c| c as u8)
|
|
.collect();
|
|
String::from_utf8_lossy(&bytes).into_owned()
|
|
}
|
|
|
|
/// Formats any Display error to "Error: {}" string
|
|
pub fn err_to_string<E: std::fmt::Display>(e: E) -> String {
|
|
format!("Error: {}", e)
|
|
}
|
|
|
|
/// Finds memory patterns in text using parentheses parsing
|
|
pub fn find_memory_pattern(text: &str) -> Option<(usize, &str)> {
|
|
// Find the last parenthesis that contains the memory pattern
|
|
let mut last_match = None;
|
|
let mut chars = text.char_indices().peekable();
|
|
|
|
while let Some((start_idx, ch)) = chars.next() {
|
|
if ch == '(' {
|
|
// Find the closing parenthesis
|
|
let remaining = &text[start_idx + 1..];
|
|
if let Some(close_pos) = remaining.find(')') {
|
|
let content = &remaining[..close_pos];
|
|
|
|
// Check if this looks like memory info
|
|
if is_memory_pattern(content) {
|
|
last_match = Some((start_idx, content));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
last_match
|
|
}
|
|
|
|
/// Validates if content matches memory pattern format
|
|
pub fn is_memory_pattern(content: &str) -> bool {
|
|
// Check if content matches pattern like "8128 MiB, 8128 MiB free"
|
|
// Must contain: numbers, "MiB", comma, "free"
|
|
if !(content.contains("MiB") && content.contains("free") && content.contains(',')) {
|
|
return false;
|
|
}
|
|
|
|
let parts: Vec<&str> = content.split(',').collect();
|
|
if parts.len() != 2 {
|
|
return false;
|
|
}
|
|
|
|
parts.iter().all(|part| {
|
|
let part = part.trim();
|
|
// Each part should start with a number and contain "MiB"
|
|
part.split_whitespace()
|
|
.next()
|
|
.map_or(false, |first_word| first_word.parse::<i32>().is_ok())
|
|
&& part.contains("MiB")
|
|
})
|
|
}
|