pub const CUSTOM_TEMPLATE_NAME: &str = "custom";pub const DEFAULT_TEMPLATE_NAME: &str = "default";pub const PROGRESS_SPINNER_TICK: u64 = 120;Module for the codeprompt constants.
+pub fn parse_comma_delim_patterns(patterns: &Option<String>) -> Vec<String>pub fn traverse_directory(
+ root: &Path,
+ include: &[String],
+ exclude: &[String],
+ include_priority: bool,
+ line_numbers: bool,
+ relative_paths: bool,
+ exclude_from_tree: bool,
+ no_codeblock: bool,
+ gitignore: bool,
+ verbose: bool
+) -> Result<(String, Vec<Value>)>Starts at the directory root path and traverses the files to build a tree representation.
+root: The path to the root directory.include: The include patterns.exclude: The exclude patterns.include_priority: Whether to give priority to the include patterns.line_numbers: Whether to add line numbers to the code sections.relative_paths: Whether to use relative paths in the file tree.exclude_from_tree: Whether to exclude files picked up by the exclude patterns from the
+tree.no_codeblock: Whether to wrap the code in markdown code blocks.gitignore: Whether or not to respect the gitignore file.verbose: Whether to print the glob pattern matching for investigation.Result<(String, Vec<serde_json::Value>)>: The string representation of the tree and the
+JSON representation.Files Module
+Module that handles all file and file pathing functionality.
+pub async fn fetch_github_issue(
+ owner: &str,
+ repo: &str,
+ issue_number: u32
+) -> Result<Issue, Error>Fetches a Github issue using the Github API.
+owner: The owner (username or organization) of the repository.repo: The name of the repository.issue_number: The number of the issue to fetch.Result<Issue, Error>: An Issue struct containing the fetched issue details on success, or
+an Error if the API request fails or the response cannot be parsed.This function will return an error if:
+pub fn get_repo_info(repo: &Repository) -> Result<(String, String), Error>Extracts the owner and repository name from a Git repository.
+Attempts to parse the remote URL of the repository and extract the owner (username or +organization) and the repository name.
+repo: The Git repository to extract information from.Result<(String, String), Error>: A tuple containing the owner and repository name on
+success, or an Error if the information cannot be extracted.pub fn git_diff(repo: &Repository, mode: u8) -> Result<String, Error>Generates a git diff in the repository.
+path: The path to the repository.mode: The git diff mode to run:
+0: for diff_tree_to_index (staged changes)1: for diff_index_to_workdir (unstaged changes)2: for both staged and unstaged changesResult<String, anyhow::Error>: A string containing the git diff on success, or an Error if
+the diff generation fails.Git Module
+Module that handles the Git operation functionality.
+pub struct Issue {
+ pub number: u32,
+ pub title: String,
+ pub body: Option<String>,
+ pub state: String,
+ pub html_url: String,
+}Struct to represent a parsed Github issue.
+number: u32The github issue number.
+title: StringThe github issue title.
+body: Option<String>The github issue body.
+state: StringThe github issue state.
+html_url: Stringthe github issue raw HTML url.
+Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreEasy import prelude module.
+pub use crate::files::basename;pub use crate::files::parse_comma_delim_patterns;pub use crate::files::traverse_directory;pub use crate::git::git_diff;pub use crate::git::get_repo_info;pub use crate::git::fetch_github_issue;pub use crate::spinner::setup_spinner;pub use crate::template::get_template;pub use crate::template::render_template;pub use crate::template::setup_handlebars_registry;pub use crate::tokenizer::tokenizer_init;pub fn setup_spinner(message: &str) -> ProgressBarModule that handles the spinner (progress indicator).
+pub fn get_template<'a>(path: &'a Option<PathBuf>) -> Result<(String, &'a str)>Retrieve the template content and name based on the user passed arguments. If no template +argument is passed by the user defaults to the default template.
+path: The Option containing the PathBuf from the user passed arguments.Result<(String, &str)>: A tuple containing the template content and name.pub fn render_template(
+ registry: &Handlebars<'_>,
+ template_name: &str,
+ json_data: &Value
+) -> Result<String>pub fn setup_handlebars_registry(
+ template_content: &str,
+ template_name: &str
+) -> Result<Handlebars<'static>>Handles the handlebars template integration including setting up the Handlebars template +engine, rendering the template with the data, copying the output to the clipboard, and +writing the output to a file.
+Right now does not support user-defined variables but this is planned in the future.
+pub fn tokenizer_init(encoding: &str) -> CoreBPEHandles the tokenizer functionality.
+U::from(self).\nThe github issue number.\nThe github issue state.\nThe github issue title.\nCreates the progress indicator.\nRetrieve the template content and name based on the user …\nRenders the handlebars template.\nSets up the Handlebars template engine.\nReturns the byte pair encoder to use for tokenization.")
\ No newline at end of file
diff --git a/settings.html b/settings.html
new file mode 100644
index 0000000..af7aea0
--- /dev/null
+++ b/settings.html
@@ -0,0 +1 @@
+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 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +
//! Files Module
+//!
+//! Module that handles all file and file pathing functionality.
+
+use anyhow::Result;
+use glob::Pattern;
+use ignore::WalkBuilder;
+use serde_json::json;
+use std::fs;
+use std::path::Path;
+use termtree::Tree;
+
+/// Parses a comma-delimited list from the user arguments.
+///
+/// ### Arguments
+///
+/// - `patterns`: Optional string contining comma-delimited patterns.
+///
+/// ### Returns
+///
+/// - `Vec<String>`: The parsed list of patterns.
+///
+pub fn parse_comma_delim_patterns(patterns: &Option<String>) -> Vec<String> {
+ if let Some(patterns) = patterns {
+ if !patterns.is_empty() {
+ return patterns.split(',').map(|s| s.trim().to_owned()).collect();
+ }
+ }
+ vec![]
+}
+
+/// Starts at the directory root path and traverses the files to build a tree representation.
+///
+/// ### Arguments
+///
+/// - `root`: The path to the root directory.
+/// - `include`: The include patterns.
+/// - `exclude`: The exclude patterns.
+/// - `include_priority`: Whether to give priority to the include patterns.
+/// - `line_numbers`: Whether to add line numbers to the code sections.
+/// - `relative_paths`: Whether to use relative paths in the file tree.
+/// - `exclude_from_tree`: Whether to exclude files picked up by the exclude patterns from the
+/// tree.
+/// - `no_codeblock`: Whether to wrap the code in markdown code blocks.
+/// - `gitignore`: Whether or not to respect the gitignore file.
+/// - `verbose`: Whether to print the glob pattern matching for investigation.
+///
+/// ### Returns
+///
+/// - `Result<(String, Vec<serde_json::Value>)>`: The string representation of the tree and the
+/// JSON representation.
+///
+pub fn traverse_directory(
+ root: &Path,
+ include: &[String],
+ exclude: &[String],
+ include_priority: bool,
+ line_numbers: bool,
+ relative_paths: bool,
+ exclude_from_tree: bool,
+ no_codeblock: bool,
+ gitignore: bool,
+ verbose: bool,
+) -> Result<(String, Vec<serde_json::Value>)> {
+ // Will hold the files found in the traversal.
+ let mut files = Vec::new();
+ // Canonicalize returns the canonical, absolute form of a path with all intermediate components
+ // normalized and symbolic links resolved. It errors if the path does not exist or if the final
+ // component in path is not a directory.
+ let canonical_root_path = root.canonicalize()?;
+ let parent_dir = basename(&canonical_root_path);
+
+ if verbose {
+ println!(
+ "Include patterns: {:?}\nExclude patterns: {:?}",
+ include, exclude
+ );
+ }
+
+ // Walk through the directory tree.
+ // Initialize a WalkBuilder with the canonical root path (by default, respects .gitignore).
+ let tree = WalkBuilder::new(&canonical_root_path)
+ .git_ignore(gitignore)
+ .build()
+ // Filter out errors, only keep successful entries.
+ .filter_map(|e| e.ok())
+ // Use fold to accumulate entries into the tree structure, starting from the root
+ // directory.
+ .fold(Tree::new(parent_dir.to_owned()), |mut root, entry| {
+ let path = entry.path();
+ // Computes the relative path from the root directory.
+ if let Ok(relative_path) = path.strip_prefix(&canonical_root_path) {
+ // Initialize the current tree to the root of the tree.
+ let mut current_tree = &mut root;
+ // Iterate over each part of the relative path.
+ for component in relative_path.components() {
+ let component_string = component.as_os_str().to_string_lossy().to_string();
+ // Check if the file should be excluded from the tree based on the
+ // exclude patterns and exclude_from_tree arguments. Break the path component
+ // loop if it any part of the path should be excluded.
+ if exclude_from_tree && !include_file(path, include, exclude, include_priority, relative_paths, verbose)
+ {
+ break;
+ }
+
+ // Check if the current component already exists in the current tree.
+ current_tree = if let Some(index) = current_tree
+ .leaves
+ .iter_mut()
+ .position(|child| child.root == component_string)
+ {
+ // Update the current tree to point to the existing component.
+ &mut current_tree.leaves[index]
+ // Component doesn't already exist, create a new tree node and add to the
+ // current tree.
+ } else {
+ let new_tree = Tree::new(component_string.clone());
+ current_tree.leaves.push(new_tree);
+ current_tree.leaves.last_mut().unwrap()
+ };
+ }
+
+ if path.is_file() && include_file(path, include, exclude, include_priority, relative_paths, verbose) {
+ // Read in the file contents into bytes.
+ if let Ok(file_bytes) = fs::read(path) {
+ let code_string = String::from_utf8_lossy(&file_bytes);
+ // Get the formatted content block.
+ let formatted_block = wrap_content(
+ &code_string,
+ path.extension().and_then(|ext| ext.to_str()).unwrap_or(""),
+ line_numbers,
+ no_codeblock,
+ );
+
+ if !formatted_block.trim().is_empty()
+ && !formatted_block.contains(char::REPLACEMENT_CHARACTER)
+ {
+ // If the relative paths bool is True, get the relative path.
+ let file_path = if relative_paths {
+ format!("{}/{}", parent_dir, relative_path.display())
+ // If the relative paths bool is False, get the full path.
+ } else {
+ path.display().to_string()
+ };
+
+ files.push(json!({
+ "path": file_path,
+ "extension": path.extension().and_then(|ext| ext.to_str()).unwrap_or(""),
+ "code": formatted_block
+ }));
+ }
+ }
+ }
+ }
+ root
+ });
+ Ok((tree.to_string(), files))
+}
+
+/// Gets the basename of the filepath.
+///
+/// ### Arguments
+///
+/// - `p`: The file/directory path to process.
+///
+/// ### Returns
+///
+/// - `String`: The path basename.
+///
+pub fn basename<P>(p: P) -> String
+where
+ P: AsRef<Path>,
+{
+ let path = p.as_ref();
+ match path.file_name() {
+ Some(name) => name.to_string_lossy().into_owned(),
+ None => handle_special_case(path),
+ }
+}
+
+/// Handles the special cases for the basename function.
+///
+/// ### Arguments
+///
+/// - `p`: The special case path to process.
+///
+/// ### Returns
+/// - `String`:
+///
+fn handle_special_case(p: &Path) -> String {
+ if p.as_os_str().is_empty() || p == Path::new(".") || p == Path::new("..") {
+ std::env::current_dir()
+ .ok()
+ .and_then(|d| d.file_name().map(|n| n.to_string_lossy().into_owned()))
+ .unwrap_or_else(|| ".".to_owned())
+ } else {
+ p.to_string_lossy().into_owned()
+ }
+}
+
+/// Whether to include a file based on the include/exclude patterns.
+///
+/// ### Arguments
+///
+/// - `path`: The path to the file to check.
+/// - `include_patterns`: The include patterns.
+/// - `exclude_patterns`: The exclude patterns.
+/// - `include_priority`: Whether to put precedence on the include or exclude patterns if they
+/// conflict.
+///
+/// ### Returns
+///
+/// - `bool`: True if the file should be included, False otherwise.
+///
+fn include_file(
+ path: &Path,
+ include: &[String],
+ exclude: &[String],
+ include_priority: bool,
+ relative_paths: bool,
+ verbose: bool,
+) -> bool {
+ let canonical_root_path = match fs::canonicalize(path) {
+ Ok(path) => path,
+ Err(e) => {
+ println!("Failed to canonicalize path: {}", e);
+ return false;
+ }
+ };
+ let path_string = canonical_root_path.to_str().unwrap();
+ let relative_path = path
+ .strip_prefix(std::env::current_dir().unwrap())
+ .unwrap_or(path);
+ let relative_path_string = relative_path.to_str().unwrap();
+
+ if verbose {
+ if relative_paths {
+ println!("=> Target path: {}", relative_path_string);
+ } else {
+ println!("=> Target path: {}", path_string);
+ }
+ }
+
+ // Function to strip "./" prefix for relative paths.
+ let strip_relative_prefix: for<'a> fn(&'a str) -> &'a str = |s| s.strip_prefix("./").unwrap_or(s);
+
+ // Check the glob patterns.
+ let include_bool = include.iter().any(|pattern| {
+ let matches = if relative_paths {
+ let stripped_pattern = strip_relative_prefix(pattern);
+ Pattern::new(stripped_pattern).unwrap().matches(relative_path_string)
+ } else {
+ Pattern::new(pattern).unwrap().matches(path_string)
+ };
+ if verbose {
+ println!("\tChecking include pattern '{}': {}", pattern, matches);
+ }
+ matches
+ });
+
+ let exclude_bool = exclude.iter().any(|pattern| {
+ let matches = if relative_paths {
+ let stripped_pattern = strip_relative_prefix(pattern);
+ Pattern::new(stripped_pattern).unwrap().matches(relative_path_string)
+ } else {
+ Pattern::new(pattern).unwrap().matches(path_string)
+ };
+ if verbose {
+ println!("\tChecking exclude pattern '{}': {}", pattern, matches);
+ }
+ matches
+ });
+
+ // Determine if the file should be included.
+ let result = match (include_bool, exclude_bool) {
+ (true, true) => {
+ if verbose {
+ println!("\tMatch conflict, include priority: {}", include_priority);
+ }
+ include_priority
+ }
+ (true, false) => {
+ if verbose {
+ println!("\tInclude: true");
+ }
+ true
+ }
+ (false, true) => {
+ if verbose {
+ println!("\tInclude: false");
+ }
+ false
+ }
+ (false, false) => {
+ if verbose {
+ println!(
+ "\tNot in either condition, fallback: {}",
+ include.is_empty()
+ );
+ }
+ include.is_empty()
+ }
+ };
+
+ result
+}
+
+/// Wrap the file code content into a markdown code block and add line numbers if applicable.
+///
+/// ### Arguments
+///
+/// - `content`: The content to wrap.
+/// - `extension`: The file extension.
+/// - `line_numbers`: Whether to add line numbers.
+/// - `no_codeblock`: Whether to wrap the file content or not.
+///
+/// ### Returns
+///
+/// - `String`: The formatted file content.
+///
+fn wrap_content(content: &str, extension: &str, line_numbers: bool, no_codeblock: bool) -> String {
+ let codeblock_tick = "`".repeat(3);
+ let mut formatted_block = String::new();
+
+ if line_numbers {
+ for (idx, line) in content.lines().enumerate() {
+ formatted_block.push_str(&format!("{:4} | {}\n", idx + 1, line));
+ }
+ } else {
+ formatted_block = content.to_owned();
+ }
+
+ if no_codeblock {
+ formatted_block
+ } else {
+ format!(
+ "{}{}\n{}\n{}",
+ codeblock_tick, extension, formatted_block, codeblock_tick
+ )
+ }
+}
+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 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +
//! Git Module
+//!
+//! Module that handles the Git operation functionality.
+
+use anyhow::{anyhow, Context, Error, Result};
+use git2::{DiffFormat::Patch, DiffOptions, Repository};
+use regex::Regex;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+
+/// Struct to represent a parsed Github issue.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Issue {
+ /// The github issue number.
+ pub number: u32,
+ /// The github issue title.
+ pub title: String,
+ /// The github issue body.
+ pub body: Option<String>,
+ /// The github issue state.
+ pub state: String,
+ /// the github issue raw HTML url.
+ pub html_url: String,
+}
+
+/// Generates a git diff in the repository.
+///
+/// ### Arguments
+///
+/// - `path`: The path to the repository.
+/// - `mode`: The git diff mode to run:
+/// - `0`: for diff_tree_to_index (staged changes)
+/// - `1`: for diff_index_to_workdir (unstaged changes)
+/// - `2`: for both staged and unstaged changes
+///
+/// ### Returns
+///
+/// - `Result<String, anyhow::Error>`: A string containing the git diff on success, or an Error if
+/// the diff generation fails.
+///
+pub fn git_diff(repo: &Repository, mode: u8) -> Result<String, Error> {
+ // Resolve the reference pointed at by HEAD.
+ let head = repo.head().context("Failed to get the repository head.")?;
+ let tree = head
+ .peel_to_tree()
+ .context("Failed to peel tree at head.")?;
+
+ let mut opts = DiffOptions::new();
+
+ let diff = match mode {
+ 0 => repo
+ .diff_tree_to_index(Some(&tree), None, Some(&mut opts))
+ .context("Failed to generate tree to index diff.")?,
+ 1 => repo
+ .diff_index_to_workdir(None, Some(&mut opts))
+ .context("Failed to generate index to workdir diff.")?,
+ 2 => {
+ let mut diff = repo
+ .diff_tree_to_index(Some(&tree), None, Some(&mut opts))
+ .context("Failed to generate tree to index diff.")?;
+ diff.merge(
+ &repo
+ .diff_index_to_workdir(None, Some(&mut opts))
+ .context("Failed to generate index to workdir diff.")?,
+ )?;
+ diff
+ }
+ _ => {
+ return Err(Error::msg(format!(
+ "Invalid git diff mode. Expected 0, 1, or 2. Got {}.",
+ mode
+ )))
+ }
+ };
+
+ // Using a Vec because Vec's grow more efficiently than Strings.
+ let mut diff_text = Vec::new();
+ diff.print(Patch, |_delta, _hunk, line| {
+ let prefix = match line.origin() {
+ '+' => b'+',
+ '-' => b'-',
+ _ => b' ',
+ };
+ diff_text.push(prefix);
+ diff_text.extend_from_slice(line.content());
+ true
+ })
+ .context("Failed to generate diff")?;
+
+ Ok(String::from_utf8_lossy(&diff_text).into_owned())
+}
+
+/// Extracts the owner and repository name from a Git repository.
+///
+/// Attempts to parse the remote URL of the repository and extract the owner (username or
+/// organization) and the repository name.
+///
+/// ### Arguments
+///
+/// - `repo`: The Git repository to extract information from.
+///
+/// ### Returns
+///
+/// - `Result<(String, String), Error>`: A tuple containing the owner and repository name on
+/// success, or an Error if the information cannot be extracted.
+///
+pub fn get_repo_info(repo: &Repository) -> Result<(String, String), Error> {
+ let remote = repo
+ .find_remote("origin")
+ .context("Failed to find `origin` remote.")?;
+ let remote_url = remote.url().context("Failed to get remote URL")?;
+ let url = if remote_url.contains(".git") {
+ &remote_url.replace(".git", "")
+ } else {
+ remote_url
+ };
+
+ let re = Regex::new(r"github\.com[:/]([^/]+)/([^/]+)(?:\.git)?$").unwrap();
+ re.captures(url)
+ .and_then(|cap| {
+ Some((
+ cap.get(1).unwrap().as_str().to_owned(),
+ cap.get(2).unwrap().as_str().to_owned(),
+ ))
+ })
+ .context("Unable to parse Github repository information.")
+}
+
+/// Fetches a Github issue using the Github API.
+///
+/// ### Arguments
+///
+/// - `owner`: The owner (username or organization) of the repository.
+/// - `repo`: The name of the repository.
+/// - `issue_number`: The number of the issue to fetch.
+///
+/// ### Returns
+///
+/// - `Result<Issue, Error>`: An Issue struct containing the fetched issue details on success, or
+/// an Error if the API request fails or the response cannot be parsed.
+///
+/// ### Errors
+///
+/// This function will return an error if:
+/// - The API request fails (e.g., network issues, authentication problems)
+/// - The API response indicates a non-success status code
+/// - The API response cannot be deserialized into the Issue struct
+///
+pub async fn fetch_github_issue(
+ owner: &str,
+ repo: &str,
+ issue_number: u32,
+) -> Result<Issue, Error> {
+ let client = Client::new();
+ let url = format!(
+ "https://api.github.com/repos/{}/{}/issues/{}",
+ owner, repo, issue_number
+ );
+
+ let response = client
+ .get(&url)
+ .header("User-Agent", "codeprompt")
+ .send()
+ .await
+ .context("Failed to send issue request to Github API")?;
+
+ if response.status().is_success() {
+ let issue: Issue = response
+ .json()
+ .await
+ .context("Failed to parse Github issue API response.")?;
+ Ok(issue)
+ } else {
+ Err(anyhow!(
+ "Failed to fetch issue, status: {}, message: {}",
+ response.status(),
+ response.text().await.unwrap()
+ ))
+ }
+}
+//! # CodePrompt Crate
+
+pub mod constants {
+ //! Module for the codeprompt constants.
+ pub const DEFAULT_TEMPLATE_NAME: &str = "default";
+ pub const CUSTOM_TEMPLATE_NAME: &str = "custom";
+ pub const PROGRESS_SPINNER_TICK: u64 = 120;
+}
+
+pub mod files;
+pub mod git;
+pub mod spinner;
+pub mod template;
+pub mod tokenizer;
+
+pub mod prelude {
+ //! Easy import prelude module.
+ pub use crate::files::{basename, parse_comma_delim_patterns, traverse_directory};
+ pub use crate::git::{git_diff, get_repo_info, fetch_github_issue};
+ pub use crate::spinner::setup_spinner;
+ pub use crate::template::{get_template, render_template, setup_handlebars_registry};
+ pub use crate::tokenizer::tokenizer_init;
+}
+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 +
//! # Spinner Module
+//!
+//! Module that handles the spinner (progress indicator).
+
+use super::constants::PROGRESS_SPINNER_TICK;
+use indicatif::{ProgressBar, ProgressStyle};
+use std::time::Duration;
+
+/// Creates the progress indicator.
+///
+/// ### Arguments
+///
+/// - `message`: A message to display with the progress indicator.
+///
+/// ### Returns
+/// - `ProgressBar`: The configured progress bar.
+///
+pub fn setup_spinner(message: &str) -> ProgressBar {
+ // Setup the initial spinner.
+ let spinner = ProgressBar::new_spinner();
+ // Spawns a background thread to tick the progress bar.
+ spinner.enable_steady_tick(Duration::from_millis(PROGRESS_SPINNER_TICK));
+ spinner.set_style(
+ ProgressStyle::default_spinner()
+ .tick_strings(&[".", "..", "...", "....", "....."])
+ .template("{spinner:.blue} {msg}")
+ .unwrap(),
+ );
+ spinner.set_message(message.to_owned());
+ spinner
+}
+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 +
//! # Template Module
+//!
+//! Handles the handlebars template integration including setting up the Handlebars template
+//! engine, rendering the template with the data, copying the output to the clipboard, and
+//! writing the output to a file.
+//!
+//! Right now does not support user-defined variables but this is planned in the future.
+
+use super::constants::{CUSTOM_TEMPLATE_NAME, DEFAULT_TEMPLATE_NAME};
+use anyhow::{anyhow, Context, Result};
+use handlebars::{no_escape, Handlebars};
+use std::path::PathBuf;
+
+/// Sets up the Handlebars template engine.
+///
+/// ### Arguments
+///
+/// - `template_content`: The Handlebars template content string.
+/// - `template_name`: The name of the template.
+///
+/// ### Returns
+///
+/// - `Result<Handlebars<'static>>`: The Handlebars instance.
+///
+pub fn setup_handlebars_registry(
+ template_content: &str,
+ template_name: &str,
+) -> Result<Handlebars<'static>> {
+ // Create the handlebars registry.
+ let mut handlebars = Handlebars::new();
+ // By default, Handlebars automatically escapes HTML special characters in variable values to
+ // prevent potential cross-site scripting attacks. Since we are just creating formatted
+ // prompts, if the variable contents are HTML we want the actual HTML, not the escaped values.
+ handlebars.register_escape_fn(no_escape);
+ // Add a template to the Handlebars registry. Allows for pre-compiling and storing the template
+ // in memory.
+ handlebars
+ .register_template_string(template_name, template_content)
+ .map_err(|e| anyhow::anyhow!("Failed to register the Handlebars template: {}", e))?;
+
+ Ok(handlebars)
+}
+
+/// Retrieve the template content and name based on the user passed arguments. If no template
+/// argument is passed by the user defaults to the default template.
+///
+/// ### Arguments
+///
+/// - `path`: The Option containing the PathBuf from the user passed arguments.
+///
+/// ### Returns
+///
+/// - `Result<(String, &str)>`: A tuple containing the template content and name.
+///
+pub fn get_template<'a>(path: &'a Option<PathBuf>) -> Result<(String, &'a str)> {
+ // Grab the custom template content if provided.
+ if let Some(template_path) = path {
+ let content = std::fs::read_to_string(template_path)
+ .context("Failed to read custom template path.")?;
+ Ok((content, CUSTOM_TEMPLATE_NAME))
+ // Fallback to default template.
+ } else {
+ // Use the include_str! macro to include the contents of the file as a string literal with a
+ // `static lifetime in the code at compile time.
+ Ok((
+ include_str!(concat!(
+ env!("CARGO_MANIFEST_DIR"),
+ "/src/templates/default_template.hbs"
+ ))
+ .to_owned(),
+ DEFAULT_TEMPLATE_NAME,
+ ))
+ }
+}
+
+/// Renders the handlebars template.
+///
+/// ### Arguments
+///
+/// - `registry`: The handlebars registry.
+/// - `template_name`: The handlebars template name.
+/// - `json_data`: The formatted JSON data.
+///
+/// ### Returns
+///
+/// - `Result<String>`:
+///
+pub fn render_template(
+ registry: &Handlebars,
+ template_name: &str,
+ json_data: &serde_json::Value,
+) -> Result<String> {
+ let rendered_output = registry
+ .render(template_name, json_data)
+ .map_err(|e| anyhow!("Failed to render template: {}", e))?;
+ Ok(rendered_output.trim().to_owned())
+}
+//! # Tokenizer Module
+//!
+//! Handles the tokenizer functionality.
+
+use tiktoken_rs::{cl100k_base, CoreBPE};
+
+/// Returns the byte pair encoder to use for tokenization.
+///
+/// ### Arguments
+///
+/// - `encoding`: Specifies the encoding to use for the tokenization.
+///
+/// ### Returns
+///
+/// - `CoreBPE`: The tokenizer.
+///
+pub fn tokenizer_init(encoding: &str) -> CoreBPE {
+ match encoding.to_lowercase().trim() {
+ "cl100k" => cl100k_base().unwrap(),
+ _ => cl100k_base().unwrap(),
+ }
+}
+fn:) to \
+ restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \
+ enum, trait, type, macro, \
+ and const.","Search functions by type signature (e.g., vec -> usize or \
+ -> vec or String, enum:Cow -> bool)","You can look for items with an exact name by putting double quotes around \
+ your request: \"string\"","Look for functions that accept or return \
+ slices and \
+ arrays by writing \
+ square brackets (e.g., -> [u8] or [] -> Option)","Look for items inside another one by searching for a path: vec::Vec",].map(x=>""+x+"
").join("");const div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="${value.replaceAll(" ", " ")}`}else{error[index]=value}});output+=`