snippy 0.1.0

A command-line tool for that makes using LLMs for code generation a breeze
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

use crate::reporting::print_stats;
use crate::utils::{expand_patterns, format_content, read_file_content};
use crate::{ClipboardCopierConfig, ClipboardError};
use arboard::Clipboard;
use async_trait::async_trait;
use std::collections::HashMap;
use std::path::PathBuf;
use tiktoken_rs::get_bpe_from_model;
use tracing::{debug, info, trace, warn};

#[async_trait]
pub trait ClipboardCopier {
    async fn copy_files_to_clipboard(&self, files: Vec<String>) -> Result<(), ClipboardError>;
}

pub struct BasicClipboardCopier {
    config: ClipboardCopierConfig,
}

impl BasicClipboardCopier {
    pub fn new(config: ClipboardCopierConfig) -> Self {
        BasicClipboardCopier { config }
    }
}

#[async_trait]
impl ClipboardCopier for BasicClipboardCopier {
    async fn copy_files_to_clipboard(&self, files: Vec<String>) -> Result<(), ClipboardError> {
        let copier_config = &self.config;
        debug!("Expanding file patterns");
        let file_list =
            expand_patterns(&files).map_err(|e| ClipboardError::FileReadError(e.to_string()))?;

        debug!("Initializing clipboard");
        let mut clipboard =
            Clipboard::new().map_err(|e| ClipboardError::ClipboardInitError(e.to_string()))?;

        let mut all_content = String::new();

        let tokenizer = get_bpe_from_model(&copier_config.model)
            .map_err(|e| ClipboardError::TokenizerModelError(e.to_string()))?;
        let mut token_counts: HashMap<PathBuf, usize> = HashMap::new();

        for file in file_list {
            debug!("Processing file: {}", file);
            match read_file_content(&file).await {
                Ok(content) => {
                    debug!("Read content for file: {}", file);
                    let formatted_content = format_content(
                        &content,
                        &file,
                        copier_config.no_markdown,
                        copier_config.line_number,
                        &copier_config.prefix,
                        copier_config.filename_format.clone(),
                    )?;
                    trace!("Formatted content for file: {}", file);
                    all_content.push_str(&formatted_content);

                    if !copier_config.no_stats {
                        trace!("Encoding content to get token count for file: {}", file);
                        let tokens = tokenizer.encode_ordinary(&formatted_content);
                        let token_count = tokens.len();
                        token_counts.insert(PathBuf::from(&file), token_count);
                        trace!("File {} has {} tokens", &file, token_count);
                    }
                }
                Err(e) => {
                    warn!("Failed to read file {}: {}", &file, e);
                }
            }
        }

        let final_content = format!("{}{}", copier_config.first_line, all_content);
        trace!("Final content length: {}", final_content.len());

        if !copier_config.no_stats {
            print_stats(&token_counts)?;
        }

        clipboard
            .set_text(final_content)
            .map_err(|e| ClipboardError::ClipboardWriteError(e.to_string()))?;

        info!("Files copied to clipboard successfully.");
        Ok(())
    }
}

pub async fn copy_files_to_clipboard(
    config: ClipboardCopierConfig,
    files: Vec<String>,
) -> Result<(), ClipboardError> {
    let copier = BasicClipboardCopier::new(config);
    copier.copy_files_to_clipboard(files).await
}