Remove legacy modules and unused dependencies

11 files changed, 0 insertions, 1423 deletions

diff --git a/utils/src/legacy.rs b/utils/src/legacy.rs
deleted file mode 100644
index 682c679..0000000
--- a/utils/src/legacy.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-pub mod display;
-pub mod env;
-pub mod fs;
-pub mod globber;
-pub mod input;
-pub mod levenshtein_distance;
-pub mod logger;
-pub mod push_version;
-pub mod socket_addr_helper;
diff --git a/utils/src/legacy/display.rs b/utils/src/legacy/display.rs
deleted file mode 100644
index 57f4f5b..0000000
--- a/utils/src/legacy/display.rs
+++ /dev/null
@@ -1,490 +0,0 @@
-#![allow(clippy::all)]
-
-use colored::*;
-use just_enough_vcs::lib::data::sheet::SheetMappingMetadata;
-use std::{
-    collections::{BTreeMap, HashMap, VecDeque},
-    path::PathBuf,
-};
-
-pub struct SimpleTable {
-    items: Vec<String>,
-    line: Vec<Vec<String>>,
-    length: Vec<usize>,
-    padding: usize,
-}
-
-impl SimpleTable {
-    /// Create a new Table
-    pub fn new(items: Vec<impl Into<String>>) -> Self {
-        Self::new_with_padding(items, 2)
-    }
-
-    /// Create a new Table with padding
-    pub fn new_with_padding(items: Vec<impl Into<String>>, padding: usize) -> Self {
-        let items: Vec<String> = items.into_iter().map(|v| v.into()).collect();
-        let mut length = Vec::with_capacity(items.len());
-
-        for item in &items {
-            length.push(display_width(item));
-        }
-
-        SimpleTable {
-            items,
-            padding,
-            line: Vec::new(),
-            length,
-        }
-    }
-
-    /// Push a new row of items to the table
-    pub fn push_item(&mut self, items: Vec<impl Into<String>>) {
-        let items: Vec<String> = items.into_iter().map(|v| v.into()).collect();
-
-        let mut processed_items = Vec::with_capacity(self.items.len());
-
-        for i in 0..self.items.len() {
-            if i < items.len() {
-                processed_items.push(items[i].clone());
-            } else {
-                processed_items.push(String::new());
-            }
-        }
-
-        for (i, d) in processed_items.iter().enumerate() {
-            let d_len = display_width(d);
-            if d_len > self.length[i] {
-                self.length[i] = d_len;
-            }
-        }
-
-        self.line.push(processed_items);
-    }
-
-    /// Insert a new row of items at the specified index
-    pub fn insert_item(&mut self, index: usize, items: Vec<impl Into<String>>) {
-        let items: Vec<String> = items.into_iter().map(|v| v.into()).collect();
-
-        let mut processed_items = Vec::with_capacity(self.items.len());
-
-        for i in 0..self.items.len() {
-            if i < items.len() {
-                processed_items.push(items[i].clone());
-            } else {
-                processed_items.push(String::new());
-            }
-        }
-
-        for (i, d) in processed_items.iter().enumerate() {
-            let d_len = display_width(d);
-            if d_len > self.length[i] {
-                self.length[i] = d_len;
-            }
-        }
-
-        self.line.insert(index, processed_items);
-    }
-
-    /// Get the current maximum column widths
-    fn get_column_widths(&self) -> &[usize] {
-        &self.length
-    }
-}
-
-impl std::fmt::Display for SimpleTable {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let column_widths = self.get_column_widths();
-
-        // Build the header row
-        let header: Vec<String> = self
-            .items
-            .iter()
-            .enumerate()
-            .map(|(i, item)| {
-                let target_width = column_widths[i] + self.padding;
-                let current_width = display_width(item);
-                let space_count = target_width - current_width;
-                let space = " ".repeat(space_count);
-                let result = format!("{}{}", item, space);
-                result
-            })
-            .collect();
-        writeln!(f, "{}", header.join(""))?;
-
-        // Build each data row
-        for row in &self.line {
-            let formatted_row: Vec<String> = row
-                .iter()
-                .enumerate()
-                .map(|(i, cell)| {
-                    let target_width = column_widths[i] + self.padding;
-                    let current_width = display_width(cell);
-                    let space_count = target_width - current_width;
-                    let spaces = " ".repeat(space_count);
-                    let result = format!("{}{}", cell, spaces);
-                    result
-                })
-                .collect();
-            writeln!(f, "{}", formatted_row.join(""))?;
-        }
-
-        Ok(())
-    }
-}
-
-pub fn display_width(s: &str) -> usize {
-    // Filter out ANSI escape sequences before calculating width
-    let filtered_bytes = strip_ansi_escapes::strip(s);
-    let filtered_str = match std::str::from_utf8(&filtered_bytes) {
-        Ok(s) => s,
-        Err(_) => s, // Fallback to original string if UTF-8 conversion fails
-    };
-
-    let mut width = 0;
-    for c in filtered_str.chars() {
-        if c.is_ascii() {
-            width += 1;
-        } else {
-            width += 2;
-        }
-    }
-    width
-}
-
-/// Convert byte size to a human-readable string format
-///
-/// Automatically selects the appropriate unit (B, KB, MB, GB, TB) based on the byte size
-/// and formats it as a string with two decimal places
-pub fn size_str(total_size: usize) -> String {
-    if total_size < 1024 {
-        format!("{} B", total_size)
-    } else if total_size < 1024 * 1024 {
-        format!("{:.2} KB", total_size as f64 / 1024.0)
-    } else if total_size < 1024 * 1024 * 1024 {
-        format!("{:.2} MB", total_size as f64 / (1024.0 * 1024.0))
-    } else if total_size < 1024 * 1024 * 1024 * 1024 {
-        format!("{:.2} GB", total_size as f64 / (1024.0 * 1024.0 * 1024.0))
-    } else {
-        format!(
-            "{:.2} TB",
-            total_size as f64 / (1024.0 * 1024.0 * 1024.0 * 1024.0)
-        )
-    }
-}
-
-// Convert the Markdown formatted text into a format supported by the command line
-pub fn md(text: impl AsRef<str>) -> String {
-    let text = text.as_ref().trim();
-    let mut result = String::new();
-    let mut color_stack: VecDeque<String> = VecDeque::new();
-
-    let mut i = 0;
-    let chars: Vec<char> = text.chars().collect();
-
-    while i < chars.len() {
-        // Check for escape character \
-        if chars[i] == '\\' && i + 1 < chars.len() {
-            let escaped_char = chars[i + 1];
-            // Only escape specific characters
-            if matches!(escaped_char, '*' | '<' | '>' | '`') {
-                let mut escaped_text = escaped_char.to_string();
-
-                // Apply current color stack
-                for color in color_stack.iter().rev() {
-                    escaped_text = apply_color(&escaped_text, color);
-                }
-
-                result.push_str(&escaped_text);
-                i += 2;
-                continue;
-            }
-        }
-
-        // Check for color tag start [[color]]
-        if i + 1 < chars.len() && chars[i] == '[' && chars[i + 1] == '[' {
-            let mut j = i + 2;
-            while j < chars.len()
-                && !(chars[j] == ']' && j + 1 < chars.len() && chars[j + 1] == ']')
-            {
-                j += 1;
-            }
-
-            if j + 1 < chars.len() {
-                let tag_content: String = chars[i + 2..j].iter().collect();
-
-                // Check if it's a closing tag [[/]]
-                if tag_content == "/" {
-                    color_stack.pop_back();
-                    i = j + 2;
-                    continue;
-                }
-
-                // It's a color tag
-                color_stack.push_back(tag_content.clone());
-                i = j + 2;
-                continue;
-            }
-        }
-
-        // Check for bold **text**
-        if i + 1 < chars.len() && chars[i] == '*' && chars[i + 1] == '*' {
-            let mut j = i + 2;
-            while j + 1 < chars.len() && !(chars[j] == '*' && chars[j + 1] == '*') {
-                j += 1;
-            }
-
-            if j + 1 < chars.len() {
-                let bold_text: String = chars[i + 2..j].iter().collect();
-                let mut formatted_text = bold_text.bold().to_string();
-
-                // Apply current color stack
-                for color in color_stack.iter().rev() {
-                    formatted_text = apply_color(&formatted_text, color);
-                }
-
-                result.push_str(&formatted_text);
-                i = j + 2;
-                continue;
-            }
-        }
-
-        // Check for italic *text*
-        if chars[i] == '*' {
-            let mut j = i + 1;
-            while j < chars.len() && chars[j] != '*' {
-                j += 1;
-            }
-
-            if j < chars.len() {
-                let italic_text: String = chars[i + 1..j].iter().collect();
-                let mut formatted_text = italic_text.italic().to_string();
-
-                // Apply current color stack
-                for color in color_stack.iter().rev() {
-                    formatted_text = apply_color(&formatted_text, color);
-                }
-
-                result.push_str(&formatted_text);
-                i = j + 1;
-                continue;
-            }
-        }
-
-        // Check for angle-bracketed content <text>
-        if chars[i] == '<' {
-            let mut j = i + 1;
-            while j < chars.len() && chars[j] != '>' {
-                j += 1;
-            }
-
-            if j < chars.len() {
-                // Include the angle brackets in the output
-                let angle_text: String = chars[i..=j].iter().collect();
-                let mut formatted_text = angle_text.cyan().to_string();
-
-                // Apply current color stack
-                for color in color_stack.iter().rev() {
-                    formatted_text = apply_color(&formatted_text, color);
-                }
-
-                result.push_str(&formatted_text);
-                i = j + 1;
-                continue;
-            }
-        }
-
-        // Check for inline code `text`
-        if chars[i] == '`' {
-            let mut j = i + 1;
-            while j < chars.len() && chars[j] != '`' {
-                j += 1;
-            }
-
-            if j < chars.len() {
-                // Include the backticks in the output
-                let code_text: String = chars[i..=j].iter().collect();
-                let mut formatted_text = code_text.green().to_string();
-
-                // Apply current color stack
-                for color in color_stack.iter().rev() {
-                    formatted_text = apply_color(&formatted_text, color);
-                }
-
-                result.push_str(&formatted_text);
-                i = j + 1;
-                continue;
-            }
-        }
-
-        // Regular character
-        let mut current_char = chars[i].to_string();
-
-        // Apply current color stack
-        for color in color_stack.iter().rev() {
-            current_char = apply_color(&current_char, color);
-        }
-
-        result.push_str(&current_char);
-        i += 1;
-    }
-
-    result
-}
-
-// Helper function to apply color to text
-fn apply_color(text: impl AsRef<str>, color_name: impl AsRef<str>) -> String {
-    let text = text.as_ref();
-    let color_name = color_name.as_ref();
-    match color_name {
-        // Normal colors
-        "black" => text.black().to_string(),
-        "red" => text.red().to_string(),
-        "green" => text.green().to_string(),
-        "yellow" => text.yellow().to_string(),
-        "blue" => text.blue().to_string(),
-        "magenta" => text.magenta().to_string(),
-        "cyan" => text.cyan().to_string(),
-        "white" => text.white().to_string(),
-        "bright_black" => text.bright_black().to_string(),
-        "bright_red" => text.bright_red().to_string(),
-        "bright_green" => text.bright_green().to_string(),
-        "bright_yellow" => text.bright_yellow().to_string(),
-        "bright_blue" => text.bright_blue().to_string(),
-        "bright_magenta" => text.bright_magenta().to_string(),
-        "bright_cyan" => text.bright_cyan().to_string(),
-        "bright_white" => text.bright_white().to_string(),
-
-        // Short aliases for bright colors
-        "b_black" => text.bright_black().to_string(),
-        "b_red" => text.bright_red().to_string(),
-        "b_green" => text.bright_green().to_string(),
-        "b_yellow" => text.bright_yellow().to_string(),
-        "b_blue" => text.bright_blue().to_string(),
-        "b_magenta" => text.bright_magenta().to_string(),
-        "b_cyan" => text.bright_cyan().to_string(),
-        "b_white" => text.bright_white().to_string(),
-
-        // Gray colors using truecolor
-        "gray" | "grey" => text.truecolor(128, 128, 128).to_string(),
-        "bright_gray" | "bright_grey" => text.truecolor(192, 192, 192).to_string(),
-        "b_gray" | "b_grey" => text.truecolor(192, 192, 192).to_string(),
-
-        // Default to white if color not recognized
-        _ => text.to_string(),
-    }
-}
-
-/// Render a HashMap of PathBuf to SheetMappingMetadata as a tree string.
-pub fn render_share_path_tree(paths: &HashMap<PathBuf, SheetMappingMetadata>) -> String {
-    if paths.is_empty() {
-        return String::new();
-    }
-
-    // Collect all path components into a tree structure
-    let mut root = TreeNode::new("".to_string());
-
-    for (path, metadata) in paths {
-        let mut current = &mut root;
-        let components: Vec<String> = path
-            .components()
-            .filter_map(|comp| match comp {
-                std::path::Component::Normal(s) => s.to_str().map(|s| s.to_string()),
-                _ => None,
-            })
-            .collect();
-
-        for (i, comp) in components.iter().enumerate() {
-            let is_leaf = i == components.len() - 1;
-            let child = current
-                .children
-                .entry(comp.clone())
-                .or_insert_with(|| TreeNode::new(comp.clone()));
-
-            // If this is the leaf node, store the metadata
-            if is_leaf {
-                child.metadata = Some((metadata.id.clone(), metadata.version.clone()));
-            }
-
-            current = child;
-        }
-    }
-
-    // Convert tree to string representation
-    let mut result = String::new();
-    let is_root = true;
-    let prefix = String::new();
-    let last_stack = vec![true]; // Root is always "last"
-
-    add_tree_node_to_string(&root, &mut result, is_root, &prefix, &last_stack);
-
-    result
-}
-
-/// Internal tree node structure for building the path tree
-#[derive(Debug)]
-struct TreeNode {
-    name: String,
-    children: BTreeMap<String, TreeNode>, // Use BTreeMap for sorted output
-    metadata: Option<(String, String)>,   // Store (id, version) for leaf nodes
-}
-
-impl TreeNode {
-    fn new(name: String) -> Self {
-        Self {
-            name,
-            children: BTreeMap::new(),
-            metadata: None,
-        }
-    }
-}
-
-/// Recursively add tree node to string representation
-fn add_tree_node_to_string(
-    node: &TreeNode,
-    result: &mut String,
-    is_root: bool,
-    prefix: &str,
-    last_stack: &[bool],
-) {
-    if !is_root {
-        // Add the tree prefix for this node
-        for &is_last in &last_stack[1..] {
-            if is_last {
-                result.push_str("    ");
-            } else {
-                result.push_str("│   ");
-            }
-        }
-
-        // Add the connector for this node
-        if let Some(&is_last) = last_stack.last() {
-            if is_last {
-                result.push_str("└── ");
-            } else {
-                result.push_str("├── ");
-            }
-        }
-
-        // Add node name
-        result.push_str(&node.name);
-
-        // Add metadata for leaf nodes
-        if let Some((id, version)) = &node.metadata {
-            // Truncate id to first 11 characters
-            let truncated_id = if id.len() > 11 { &id[..11] } else { id };
-            result.push_str(&format!(" [{}|{}]", truncated_id, version));
-        }
-
-        result.push('\n');
-    }
-
-    // Process children
-    let child_count = node.children.len();
-    for (i, (_, child)) in node.children.iter().enumerate() {
-        let is_last_child = i == child_count - 1;
-        let mut new_last_stack = last_stack.to_vec();
-        new_last_stack.push(is_last_child);
-
-        add_tree_node_to_string(child, result, false, prefix, &new_last_stack);
-    }
-}
diff --git a/utils/src/legacy/env.rs b/utils/src/legacy/env.rs
deleted file mode 100644
index b4ad089..0000000
--- a/utils/src/legacy/env.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use std::path::PathBuf;
-
-/// Returns the current locale string based on environment variables.
-///
-/// The function checks for locale settings in the following order:
-/// 1. JV_LANG environment variable
-/// 2. APP_LANG environment variable
-/// 3. LANG environment variable (extracts base language before dot and replaces underscores with hyphens)
-/// 4. Defaults to "en" if no locale environment variables are found
-///
-/// # Returns
-/// A String containing the detected locale code
-pub fn current_locales() -> String {
-    if let Ok(lang) = std::env::var("JV_LANG") {
-        return lang;
-    }
-
-    if let Ok(lang) = std::env::var("APP_LANG") {
-        return lang;
-    }
-
-    if let Ok(lang) = std::env::var("LANG") {
-        if let Some(base_lang) = lang.split('.').next() {
-            return base_lang.replace('_', "-");
-        }
-        return lang;
-    }
-
-    "en".to_string()
-}
-
-/// Checks if auto update is enabled based on environment variables.
-///
-/// The function checks the JV_AUTO_UPDATE environment variable and compares
-/// its value (after trimming and converting to lowercase) against known
-/// positive and negative values.
-///
-/// # Returns
-/// `true` if the value matches "yes", "y", or "true"
-/// `false` if the value matches "no", "n", or "false", or if the variable is not set
-pub fn enable_auto_update() -> bool {
-    if let Ok(auto_update) = std::env::var("JV_AUTO_UPDATE") {
-        let normalized = auto_update.trim().to_lowercase();
-        match normalized.as_str() {
-            "yes" | "y" | "true" => return true,
-            "no" | "n" | "false" => return false,
-            _ => {}
-        }
-    }
-    false
-}
-
-/// Gets the auto update expiration time based on environment variables.
-///
-/// The function checks the JV_OUTDATED_MINUTES environment variable.
-/// Requires JV_AUTO_UPDATE to be enabled.
-/// Next time the `jv` command is used, if the content is outdated, `jv update` will be automatically executed.
-///
-/// # Returns
-/// - When the set number is < 0, timeout-based update is disabled
-/// - When the set number = 0, update runs every time (not recommended)
-/// - When the set number > 0, update according to the specified time
-/// - If not set or conversion error occurs, the default is -1
-pub fn auto_update_outdate() -> i64 {
-    if !enable_auto_update() {
-        return -1;
-    }
-
-    match std::env::var("JV_OUTDATED_MINUTES") {
-        Ok(value) => value.trim().parse::<i64>().unwrap_or(-1),
-        Err(_) => -1,
-    }
-}
-
-/// Gets the default text editor based on environment variables.
-///
-/// The function checks the JV_TEXT_EDITOR and EDITOR environment variables
-/// and returns their values if they are set. If neither variable is set,
-/// it returns "jvii" as the default editor.
-///
-/// # Returns
-/// A String containing the default text editor
-pub async fn get_default_editor() -> String {
-    if let Ok(editor) = std::env::var("JV_TEXT_EDITOR") {
-        return editor;
-    }
-
-    if let Ok(editor) = std::env::var("EDITOR") {
-        return editor;
-    }
-
-    "jvii".to_string()
-}
-
-/// Get temporary file path
-pub fn current_tempfile_path(name: &str) -> Option<PathBuf> {
-    dirs::config_local_dir().map(|path| {
-        if cfg!(target_os = "linux") {
-            path.join("jvcs").join(".temp").join(name)
-        } else {
-            path.join("JustEnoughVCS").join(".temp").join(name)
-        }
-    })
-}
diff --git a/utils/src/legacy/fs.rs b/utils/src/legacy/fs.rs
deleted file mode 100644
index 0050cf1..0000000
--- a/utils/src/legacy/fs.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-pub async fn move_across_partitions(
-    source_path: impl AsRef<std::path::Path>,
-    dest_path: impl AsRef<std::path::Path>,
-) -> Result<(), std::io::Error> {
-    let source_path = source_path.as_ref();
-    let dest_path = dest_path.as_ref();
-    if !source_path.exists() {
-        return Err(std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "Source file does not exist",
-        ));
-    }
-
-    if let Ok(()) = std::fs::rename(source_path, dest_path) {
-        return Ok(());
-    }
-
-    std::fs::copy(source_path, dest_path)?;
-    std::fs::remove_file(source_path)?;
-
-    Ok(())
-}
-
-pub async fn copy_across_partitions(
-    source_path: impl AsRef<std::path::Path>,
-    dest_path: impl AsRef<std::path::Path>,
-) -> Result<(), std::io::Error> {
-    let source_path = source_path.as_ref();
-    let dest_path = dest_path.as_ref();
-    if !source_path.exists() {
-        return Err(std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "Source file does not exist",
-        ));
-    }
-
-    std::fs::copy(source_path, dest_path)?;
-
-    Ok(())
-}
diff --git a/utils/src/legacy/globber.rs b/utils/src/legacy/globber.rs
deleted file mode 100644
index b6a3032..0000000
--- a/utils/src/legacy/globber.rs
+++ /dev/null
@@ -1,292 +0,0 @@
-use std::{io::Error, path::PathBuf, str::FromStr};
-
-use just_fmt::fmt_path::fmt_path_str;
-
-use crate::legacy::globber::constants::{SPLIT_STR, get_base_dir_current};
-
-pub struct Globber {
-    pattern: String,
-    base: PathBuf,
-    names: Vec<String>,
-}
-
-#[allow(dead_code)]
-impl Globber {
-    pub fn new(pattern: String, base: PathBuf) -> Self {
-        Self {
-            pattern,
-            base,
-            names: Vec::new(),
-        }
-    }
-
-    pub fn names(&self) -> Vec<&String> {
-        self.names.iter().collect()
-    }
-
-    pub fn base(&self) -> &PathBuf {
-        &self.base
-    }
-
-    pub fn into_names(self) -> Vec<String> {
-        self.names
-    }
-
-    pub fn paths(&self) -> Vec<PathBuf> {
-        self.names.iter().map(|n| self.base.join(n)).collect()
-    }
-
-    pub fn glob<F>(mut self, get_names: F) -> Result<Self, std::io::Error>
-    where
-        F: Fn(PathBuf) -> Vec<GlobItem>,
-    {
-        let full_path = format!("{}{}{}", self.base.display(), SPLIT_STR, self.pattern);
-
-        let (path, pattern) = if let Some(last_split) = full_path.rfind(SPLIT_STR) {
-            let (path_part, pattern_part) = full_path.split_at(last_split);
-            let mut path = path_part.to_string();
-            if !path.ends_with(SPLIT_STR) {
-                path.push_str(SPLIT_STR);
-            }
-            let Ok(result) = fmt_path_str(&path) else {
-                return Err(Error::new(
-                    std::io::ErrorKind::InvalidInput,
-                    format!("Invalid path: \"{}\"", &path),
-                ));
-            };
-            (result, pattern_part[SPLIT_STR.len()..].to_string())
-        } else {
-            (String::default(), full_path)
-        };
-
-        self.base = match PathBuf::from_str(&path) {
-            Ok(r) => r,
-            Err(_) => {
-                return Err(Error::new(
-                    std::io::ErrorKind::InvalidInput,
-                    format!("Invalid path: \"{}\"", &path),
-                ));
-            }
-        };
-
-        let pattern = if pattern.is_empty() || pattern == "." {
-            "*".to_string()
-        } else if pattern.ends_with(SPLIT_STR) {
-            format!("{}*", pattern)
-        } else {
-            pattern
-        };
-
-        if !pattern.contains('*') && !pattern.contains('?') {
-            self.names = vec![pattern];
-            return Ok(self);
-        }
-
-        let mut collected = Vec::new();
-
-        collect_files(&path.into(), "./".to_string(), &mut collected, &get_names);
-        fn collect_files<F>(
-            base: &PathBuf,
-            current: String,
-            file_names: &mut Vec<String>,
-            get_names: &F,
-        ) where
-            F: Fn(PathBuf) -> Vec<GlobItem>,
-        {
-            let current_path = if current.is_empty() {
-                base.clone()
-            } else {
-                base.join(&current)
-            };
-
-            let items = get_names(current_path);
-            for item in items {
-                match item {
-                    GlobItem::File(file_name) => {
-                        let relative_path = {
-                            fmt_path_str(format!("{}{}{}", current, SPLIT_STR, file_name))
-                                .unwrap_or_default()
-                        };
-                        file_names.push(relative_path)
-                    }
-                    GlobItem::Directory(dir_name) => {
-                        let new_current = {
-                            fmt_path_str(format!("{}{}{}", current, SPLIT_STR, dir_name))
-                                .unwrap_or_default()
-                        };
-                        collect_files(base, new_current, file_names, get_names);
-                    }
-                }
-            }
-        }
-
-        self.names = collected
-            .iter()
-            .filter_map(|name| match_pattern(name, &pattern))
-            .collect();
-
-        Ok(self)
-    }
-}
-
-fn match_pattern(name: &str, pattern: &str) -> Option<String> {
-    if pattern.is_empty() {
-        return None;
-    }
-
-    let name_chars: Vec<char> = name.chars().collect();
-    let pattern_chars: Vec<char> = pattern.chars().collect();
-
-    let mut name_idx = 0;
-    let mut pattern_idx = 0;
-    let mut star_idx = -1;
-    let mut match_idx = -1;
-
-    while name_idx < name_chars.len() {
-        if pattern_idx < pattern_chars.len()
-            && (pattern_chars[pattern_idx] == '?'
-                || pattern_chars[pattern_idx] == name_chars[name_idx])
-        {
-            name_idx += 1;
-            pattern_idx += 1;
-        } else if pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' {
-            star_idx = pattern_idx as i32;
-            match_idx = name_idx as i32;
-            pattern_idx += 1;
-        } else if star_idx != -1 {
-            pattern_idx = (star_idx + 1) as usize;
-            match_idx += 1;
-            name_idx = match_idx as usize;
-        } else {
-            return None;
-        }
-    }
-
-    while pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' {
-        pattern_idx += 1;
-    }
-
-    if pattern_idx == pattern_chars.len() {
-        Some(name.to_string())
-    } else {
-        None
-    }
-}
-
-impl<T: AsRef<str>> From<T> for Globber {
-    fn from(pattern: T) -> Self {
-        let (base_dir, pattern) = get_base_dir_current(pattern.as_ref().to_string());
-        Self::new(pattern, base_dir)
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum GlobItem {
-    File(String),
-    Directory(String),
-}
-
-impl PartialEq for GlobItem {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (GlobItem::File(a), GlobItem::File(b)) => a == b,
-            (GlobItem::Directory(a), GlobItem::Directory(b)) => a == b,
-            _ => false,
-        }
-    }
-}
-
-impl std::fmt::Display for GlobItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GlobItem::File(name) => write!(f, "{}", name),
-            GlobItem::Directory(name) => write!(f, "{}", name),
-        }
-    }
-}
-
-impl std::hash::Hash for GlobItem {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        match self {
-            GlobItem::File(name) => {
-                state.write_u8(0);
-                name.hash(state);
-            }
-            GlobItem::Directory(name) => {
-                state.write_u8(1);
-                name.hash(state);
-            }
-        }
-    }
-}
-
-impl Eq for GlobItem {}
-
-pub mod constants {
-    use std::{env::current_dir, path::PathBuf};
-
-    #[cfg(unix)]
-    pub(crate) const CURRENT_DIR_PREFIX: &str = "./";
-    #[cfg(windows)]
-    pub(crate) const CURRENT_DIR_PREFIX: &str = ".\\";
-
-    #[cfg(unix)]
-    pub(crate) const USER_DIR_PREFIX: &str = "~";
-    #[cfg(windows)]
-    pub(crate) const USER_DIR_PREFIX: &str = "~\\";
-
-    #[cfg(unix)]
-    pub(crate) const ROOT_DIR_PREFIX: &str = "/";
-    #[cfg(windows)]
-    pub(crate) const ROOT_DIR_PREFIX: &str = "\\";
-
-    #[cfg(unix)]
-    pub(crate) const SPLIT_STR: &str = "/";
-    #[cfg(windows)]
-    pub(crate) const SPLIT_STR: &str = "\\";
-
-    pub fn get_base_dir_current(input: String) -> (PathBuf, String) {
-        get_base_dir(input, current_dir().unwrap_or_default())
-    }
-
-    pub fn get_base_dir(input: String, current_dir: PathBuf) -> (PathBuf, String) {
-        if let Some(remaining) = input.strip_prefix(CURRENT_DIR_PREFIX) {
-            (current_dir, remaining.to_string())
-        } else if let Some(remaining) = input.strip_prefix(USER_DIR_PREFIX) {
-            (dirs::home_dir().unwrap_or_default(), remaining.to_string())
-        } else if let Some(remaining) = input.strip_prefix(ROOT_DIR_PREFIX) {
-            {
-                #[cfg(unix)]
-                {
-                    (PathBuf::from(ROOT_DIR_PREFIX), remaining.to_string())
-                }
-                #[cfg(windows)]
-                {
-                    let current_drive = current_dir
-                        .components()
-                        .find_map(|comp| {
-                            if let std::path::Component::Prefix(prefix_component) = comp {
-                                Some(prefix_component)
-                            } else {
-                                None
-                            }
-                        })
-                        .and_then(|prefix_component| match prefix_component.kind() {
-                            std::path::Prefix::Disk(drive_letter)
-                            | std::path::Prefix::VerbatimDisk(drive_letter) => {
-                                Some((drive_letter as char).to_string())
-                            }
-                            _ => None,
-                        })
-                        .unwrap_or_else(|| "C".to_string());
-                    (
-                        PathBuf::from(format!("{}:{}", current_drive, ROOT_DIR_PREFIX)),
-                        remaining.to_string(),
-                    )
-                }
-            }
-        } else {
-            (current_dir, input)
-        }
-    }
-}
diff --git a/utils/src/legacy/input.rs b/utils/src/legacy/input.rs
deleted file mode 100644
index 501ce69..0000000
--- a/utils/src/legacy/input.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-use tokio::{fs, process::Command};
-
-use crate::legacy::env::get_default_editor;
-
-/// Confirm the current operation
-/// Waits for user input of 'y' or 'n'
-pub async fn confirm_hint(text: impl Into<String>) -> bool {
-    use tokio::io::{self, AsyncBufReadExt, AsyncWriteExt, BufReader};
-
-    let prompt = text.into().trim().to_string();
-
-    let mut stdout = io::stdout();
-    let mut stdin = BufReader::new(io::stdin());
-
-    stdout
-        .write_all(prompt.as_bytes())
-        .await
-        .expect("Failed to write prompt");
-    stdout.flush().await.expect("Failed to flush stdout");
-
-    let mut input = String::new();
-    stdin
-        .read_line(&mut input)
-        .await
-        .expect("Failed to read input");
-
-    input.trim().eq_ignore_ascii_case("y")
-}
-
-/// Confirm the current operation, or execute a closure if rejected
-/// Waits for user input of 'y' or 'n'
-/// If 'n' is entered, executes the provided closure and returns false
-pub async fn confirm_hint_or<F>(text: impl Into<String>, on_reject: F) -> bool
-where
-    F: FnOnce(),
-{
-    let confirmed = confirm_hint(text).await;
-    if !confirmed {
-        on_reject();
-    }
-    confirmed
-}
-
-/// Confirm the current operation, and execute a closure if confirmed
-/// Waits for user input of 'y' or 'n'
-/// If 'y' is entered, executes the provided closure and returns true
-pub async fn confirm_hint_then<F>(text: impl Into<String>, on_confirm: F) -> bool
-where
-    F: FnOnce(),
-{
-    let confirmed = confirm_hint(text).await;
-    if confirmed {
-        on_confirm();
-    }
-    confirmed
-}
-
-/// Input text using the system editor
-/// Opens the system editor (from EDITOR environment variable) with default text in a cache file,
-/// then reads back the modified content after the editor closes, removing comment lines
-pub async fn input_with_editor(
-    default_text: impl AsRef<str>,
-    cache_file: impl AsRef<std::path::Path>,
-    comment_char: impl AsRef<str>,
-) -> Result<String, std::io::Error> {
-    input_with_editor_cutsom(
-        default_text,
-        cache_file,
-        comment_char,
-        get_default_editor().await,
-    )
-    .await
-}
-
-pub async fn input_with_editor_cutsom(
-    default_text: impl AsRef<str>,
-    cache_file: impl AsRef<std::path::Path>,
-    comment_char: impl AsRef<str>,
-    editor: String,
-) -> Result<String, std::io::Error> {
-    let cache_path = cache_file.as_ref();
-    let default_content = default_text.as_ref();
-    let comment_prefix = comment_char.as_ref();
-
-    // Write default text to cache file
-    fs::write(cache_path, default_content).await?;
-
-    // Open editor with cache file
-    let status = Command::new(editor).arg(cache_path).status().await?;
-
-    if !status.success() {
-        return Err(std::io::Error::other("Editor exited with non-zero status"));
-    }
-
-    // Read the modified content
-    let content = fs::read_to_string(cache_path).await?;
-
-    // Remove comment lines and trim
-    let processed_content: String = content
-        .lines()
-        .filter(|line| !line.trim().starts_with(comment_prefix))
-        .collect::<Vec<&str>>()
-        .join("\n");
-
-    // Delete the cache file
-    let _ = fs::remove_file(cache_path).await;
-
-    Ok(processed_content)
-}
-
-/// Show text using the system pager (less)
-/// Opens the system pager (less) with the given text content written to the specified file
-/// If less is not found, directly outputs the content to stdout
-pub async fn show_in_pager(
-    content: impl AsRef<str>,
-    cache_file: impl AsRef<std::path::Path>,
-) -> Result<(), std::io::Error> {
-    let content_str = content.as_ref();
-    let cache_path = cache_file.as_ref();
-
-    // Write content to cache file
-    fs::write(cache_path, content_str).await?;
-
-    // Try to use less first
-    let status = Command::new("less").arg(cache_path).status().await;
-
-    match status {
-        Ok(status) if status.success() => Ok(()),
-        _ => {
-            // If less failed, output directly to stdout
-            use tokio::io::{self, AsyncWriteExt};
-            let mut stdout = io::stdout();
-            stdout
-                .write_all(content_str.as_bytes())
-                .await
-                .expect("Failed to write content");
-            stdout.flush().await.expect("Failed to flush stdout");
-            Ok(())
-        }
-    }
-}
diff --git a/utils/src/legacy/levenshtein_distance.rs b/utils/src/legacy/levenshtein_distance.rs
deleted file mode 100644
index 6bdb7e7..0000000
--- a/utils/src/legacy/levenshtein_distance.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use std::cmp::min;
-
-pub fn levenshtein_distance(a: &str, b: &str) -> usize {
-    let a_chars: Vec<char> = a.chars().collect();
-    let b_chars: Vec<char> = b.chars().collect();
-    let a_len = a_chars.len();
-    let b_len = b_chars.len();
-
-    if a_len == 0 {
-        return b_len;
-    }
-    if b_len == 0 {
-        return a_len;
-    }
-
-    let mut dp = vec![vec![0; b_len + 1]; a_len + 1];
-
-    for (i, row) in dp.iter_mut().enumerate() {
-        row[0] = i;
-    }
-
-    for (j, cell) in dp[0].iter_mut().enumerate() {
-        *cell = j;
-    }
-
-    for (i, a_char) in a_chars.iter().enumerate() {
-        for (j, b_char) in b_chars.iter().enumerate() {
-            let cost = if a_char == b_char { 0 } else { 1 };
-            dp[i + 1][j + 1] = min(dp[i][j + 1] + 1, min(dp[i + 1][j] + 1, dp[i][j] + cost));
-        }
-    }
-
-    dp[a_len][b_len]
-}
diff --git a/utils/src/legacy/logger.rs b/utils/src/legacy/logger.rs
deleted file mode 100644
index 7c18d30..0000000
--- a/utils/src/legacy/logger.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use std::path::Path;
-
-use colored::Colorize;
-use env_logger::{Builder, Target};
-use just_enough_vcs::lib::data::vault::vault_config::LoggerLevel;
-use just_fmt::fmt_path::fmt_path;
-use log::{Level, LevelFilter};
-
-pub fn build_env_logger(log_path: impl AsRef<Path>, logger_level: LoggerLevel) {
-    use std::io::{self, Write};
-
-    struct MultiWriter<A, B> {
-        a: A,
-        b: B,
-    }
-
-    impl<A: Write, B: Write> MultiWriter<A, B> {
-        fn new(a: A, b: B) -> Self {
-            Self { a, b }
-        }
-    }
-
-    impl<A: Write, B: Write> Write for MultiWriter<A, B> {
-        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-            let _ = self.a.write(buf);
-            self.b.write(buf)
-        }
-
-        fn flush(&mut self) -> io::Result<()> {
-            let _ = self.a.flush();
-            self.b.flush()
-        }
-    }
-
-    let log_path = {
-        let path = log_path.as_ref();
-        let Ok(path) = fmt_path(path) else {
-            eprintln!(
-                "Build logger failed: {} is not a vaild path.",
-                path.display()
-            );
-            return;
-        };
-        path
-    };
-
-    let mut builder = Builder::new();
-
-    let log_format = |buf: &mut env_logger::fmt::Formatter, record: &log::Record| {
-        let now = chrono::Local::now();
-
-        let level_style = match record.level() {
-            Level::Error => record.args().to_string().red().bold(),
-            Level::Warn => record.args().to_string().yellow().bold(),
-            Level::Info => record.args().to_string().white(),
-            Level::Debug => record.args().to_string().white(),
-            Level::Trace => record.args().to_string().cyan(),
-        };
-
-        writeln!(
-            buf,
-            "{} {}",
-            now.format("%H:%M:%S")
-                .to_string()
-                .truecolor(105, 105, 105)
-                .bold(),
-            level_style
-        )
-    };
-
-    let log_file = std::fs::File::create(log_path).expect("Failed to create log file");
-    let combined_target = Target::Pipe(Box::new(MultiWriter::new(std::io::stdout(), log_file)));
-
-    let level = match logger_level {
-        LoggerLevel::Debug => LevelFilter::Debug,
-        LoggerLevel::Trace => LevelFilter::Trace,
-        LoggerLevel::Info => LevelFilter::Info,
-    };
-
-    builder
-        .format(log_format)
-        .filter(None, level)
-        .filter_module("just_enough_vcs", level)
-        .target(combined_target)
-        .init();
-}
diff --git a/utils/src/legacy/push_version.rs b/utils/src/legacy/push_version.rs
deleted file mode 100644
index 6da9039..0000000
--- a/utils/src/legacy/push_version.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-pub fn push_version(current_version: impl Into<String>) -> Option<String> {
-    let version_str = current_version.into();
-    let parts: Vec<&str> = version_str.split('.').collect();
-
-    if parts.len() != 3 {
-        return None;
-    }
-
-    let major: Result<u32, _> = parts[0].parse();
-    let minor: Result<u32, _> = parts[1].parse();
-    let patch: Result<u32, _> = parts[2].parse();
-
-    if let (Ok(mut major), Ok(mut minor), Ok(mut patch)) = (major, minor, patch) {
-        patch += 1;
-
-        if patch > 99 {
-            patch = 0;
-            minor += 1;
-
-            if minor > 99 {
-                minor = 0;
-                major += 1;
-            }
-        }
-
-        Some(format!("{}.{}.{}", major, minor, patch))
-    } else {
-        None
-    }
-}
diff --git a/utils/src/legacy/socket_addr_helper.rs b/utils/src/legacy/socket_addr_helper.rs
deleted file mode 100644
index 29ccd9f..0000000
--- a/utils/src/legacy/socket_addr_helper.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-use std::net::SocketAddr;
-use tokio::net::lookup_host;
-
-/// Helper function to parse a string into a SocketAddr with optional default port
-pub async fn get_socket_addr(
-    address_str: impl AsRef<str>,
-    default_port: u16,
-) -> Result<SocketAddr, std::io::Error> {
-    let address = address_str.as_ref().trim();
-
-    // Return error if input is empty after trimming
-    if address.is_empty() {
-        return Err(std::io::Error::new(
-            std::io::ErrorKind::InvalidInput,
-            "Empty address string",
-        ));
-    }
-
-    // Check if the address contains a port
-    if let Some((host, port_str)) = parse_host_and_port(address) {
-        let port = port_str.parse::<u16>().map_err(|e| {
-            std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                format!("Invalid port number '{}': {}", port_str, e),
-            )
-        })?;
-
-        return resolve_to_socket_addr(host, port).await;
-    }
-
-    // No port specified, use default port
-    resolve_to_socket_addr(address, default_port).await
-}
-
-/// Parse host and port from address string
-fn parse_host_and_port(address: &str) -> Option<(&str, &str)> {
-    if address.starts_with('[')
-        && let Some(close_bracket) = address.find(']')
-        && close_bracket + 1 < address.len()
-        && address.as_bytes()[close_bracket + 1] == b':'
-    {
-        let host = &address[1..close_bracket];
-        let port = &address[close_bracket + 2..];
-        return Some((host, port));
-    }
-
-    // Handle IPv4 addresses and hostnames with ports
-    if let Some(colon_pos) = address.rfind(':') {
-        // Check if this is not part of an IPv6 address without brackets
-        if !address.contains('[') && !address.contains(']') {
-            let host = &address[..colon_pos];
-            let port = &address[colon_pos + 1..];
-
-            // Basic validation to avoid false positives
-            if !host.is_empty() && !port.is_empty() && port.chars().all(|c| c.is_ascii_digit()) {
-                return Some((host, port));
-            }
-        }
-    }
-
-    None
-}
-
-/// Resolve host to SocketAddr, handling both IP addresses and domain names
-async fn resolve_to_socket_addr(host: &str, port: u16) -> Result<SocketAddr, std::io::Error> {
-    // First try to parse as IP address (IPv4 or IPv6)
-    if let Ok(ip_addr) = host.parse() {
-        return Ok(SocketAddr::new(ip_addr, port));
-    }
-
-    // If it's not a valid IP address, treat it as a domain name and perform DNS lookup
-    let lookup_addr = format!("{}:{}", host, port);
-    let mut addrs = lookup_host(&lookup_addr).await?;
-
-    if let Some(addr) = addrs.next() {
-        Ok(addr)
-    } else {
-        Err(std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            format!("Could not resolve host '{}'", host),
-        ))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_ipv4_with_port() {
-        let result = get_socket_addr("127.0.0.1:8080", 80).await;
-        assert!(result.is_ok());
-        let addr = result.unwrap();
-        assert_eq!(addr.port(), 8080);
-        assert_eq!(addr.ip().to_string(), "127.0.0.1");
-    }
-
-    #[tokio::test]
-    async fn test_ipv4_without_port() {
-        let result = get_socket_addr("192.168.1.1", 443).await;
-        assert!(result.is_ok());
-        let addr = result.unwrap();
-        assert_eq!(addr.port(), 443);
-        assert_eq!(addr.ip().to_string(), "192.168.1.1");
-    }
-
-    #[tokio::test]
-    async fn test_ipv6_with_port() {
-        let result = get_socket_addr("[::1]:8080", 80).await;
-        assert!(result.is_ok());
-        let addr = result.unwrap();
-        assert_eq!(addr.port(), 8080);
-        assert_eq!(addr.ip().to_string(), "::1");
-    }
-
-    #[tokio::test]
-    async fn test_ipv6_without_port() {
-        let result = get_socket_addr("[::1]", 443).await;
-        assert!(result.is_ok());
-        let addr = result.unwrap();
-        assert_eq!(addr.port(), 443);
-        assert_eq!(addr.ip().to_string(), "::1");
-    }
-
-    #[tokio::test]
-    async fn test_invalid_port() {
-        let result = get_socket_addr("127.0.0.1:99999", 80).await;
-        assert!(result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_empty_string() {
-        let result = get_socket_addr("", 80).await;
-        assert!(result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_whitespace_trimming() {
-        let result = get_socket_addr("  127.0.0.1:8080  ", 80).await;
-        assert!(result.is_ok());
-        let addr = result.unwrap();
-        assert_eq!(addr.port(), 8080);
-    }
-
-    #[tokio::test]
-    async fn test_domain_name_with_port() {
-        // This test will only pass if localhost resolves
-        let result = get_socket_addr("localhost:8080", 80).await;
-        if result.is_ok() {
-            let addr = result.unwrap();
-            assert_eq!(addr.port(), 8080);
-            // localhost should resolve to 127.0.0.1 or ::1
-            assert!(addr.ip().is_loopback());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_domain_name_without_port() {
-        // This test will only pass if localhost resolves
-        let result = get_socket_addr("localhost", 443).await;
-        if result.is_ok() {
-            let addr = result.unwrap();
-            assert_eq!(addr.port(), 443);
-            // localhost should resolve to 127.0.0.1 or ::1
-            assert!(addr.ip().is_loopback());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_parse_host_and_port() {
-        // IPv4 with port
-        assert_eq!(
-            parse_host_and_port("192.168.1.1:8080"),
-            Some(("192.168.1.1", "8080"))
-        );
-
-        // IPv6 with port
-        assert_eq!(parse_host_and_port("[::1]:8080"), Some(("::1", "8080")));
-
-        // Hostname with port
-        assert_eq!(
-            parse_host_and_port("example.com:443"),
-            Some(("example.com", "443"))
-        );
-
-        // No port
-        assert_eq!(parse_host_and_port("192.168.1.1"), None);
-        assert_eq!(parse_host_and_port("example.com"), None);
-
-        // Invalid cases
-        assert_eq!(parse_host_and_port(":"), None);
-        assert_eq!(parse_host_and_port("192.168.1.1:"), None);
-    }
-}
diff --git a/utils/src/lib.rs b/utils/src/lib.rs
index f61179e..c76143e 100644
--- a/utils/src/lib.rs
+++ b/utils/src/lib.rs
@@ -3,6 +3,3 @@ pub mod env;
 pub mod input;
 pub mod macros;
 pub mod math;
-
-// Legacy
-pub mod legacy;