feat: implement all remaining CodeState CLI features

Author: HenryLok0

src/advanced.rs

@@ -0,0 +1,120 @@
+use std::path::PathBuf;
+use std::fs;
+use regex::Regex;
+use std::sync::OnceLock;
+use serde_json::json;
+
+pub fn style_check(paths: &[PathBuf]) {
+    println!("\n[--style-check] Checking for style issues...");
+    let mut total_issues = 0;
+    
+    for path in paths {
+        if let Ok(content) = fs::read_to_string(path) {
+            let mut issues = Vec::new();
+            let lines: Vec<&str> = content.lines().collect();
+            
+            for (i, line) in lines.iter().enumerate() {
+                let line_num = i + 1;
+                
+                // Check trailing whitespace
+                if line.ends_with(' ') || line.ends_with('\t') {
+                    issues.push(format!("Line {}: Trailing whitespace", line_num));
+                }
+                
+                // Check line length > 100
+                if line.chars().count() > 100 {
+                    issues.push(format!("Line {}: Line exceeds 100 characters", line_num));
+                }
+            }
+            
+            // Check EOF newline missing
+            if !content.is_empty() && !content.ends_with('\n') {
+                issues.push("EOF: Missing newline at end of file".to_string());
+            }
+            
+            if !issues.is_empty() {
+                println!("  {:?}:", path);
+                for issue in issues {
+                    println!("    - {}", issue);
+                    total_issues += 1;
+                }
+            }
+        }
+    }
+    
+    if total_issues == 0 {
+        println!("  No style issues found!");
+    } else {
+        println!("  Found {} style issues in total.", total_issues);
+    }
+}
+
+static ROUTE_REGEX: OnceLock<Regex> = OnceLock::new();
+
+pub fn generate_openapi(paths: &[PathBuf]) {
+    println!("\n[--openapi] Generating OpenAPI skeleton from Python files...");
+    
+    let route_re = ROUTE_REGEX.get_or_init(|| {
+        Regex::new(r#"@app\.(get|post|put|delete|patch)\(["']([^"']+)["']\)"#).unwrap()
+    });
+    
+    let mut paths_obj = serde_json::Map::new();
+    
+    for path in paths {
+        if path.extension().and_then(|e| e.to_str()) == Some("py") {
+            if let Ok(content) = fs::read_to_string(path) {
+                for cap in route_re.captures_iter(&content) {
+                    let method = cap.get(1).unwrap().as_str().to_lowercase();
+                    let route = cap.get(2).unwrap().as_str();
+                    
+                    let route_entry = paths_obj.entry(route.to_string()).or_insert(json!({}));
+                    if let Some(route_map) = route_entry.as_object_mut() {
+                        route_map.insert(method, json!({
+                            "summary": format!("Auto-generated {} route", route),
+                            "responses": {
+                                "200": {
+                                    "description": "Successful response"
+                                }
+                            }
+                        }));
+                    }
+                }
+            }
+        }
+    }
+    
+    let openapi_json = json!({
+        "openapi": "3.0.0",
+        "info": {
+            "title": "Auto-generated API",
+            "version": "1.0.0"
+        },
+        "paths": paths_obj
+    });
+    
+    println!("{}", serde_json::to_string_pretty(&openapi_json).unwrap());
+}
+
+static COVERAGE_REGEX: OnceLock<Regex> = OnceLock::new();
+
+pub fn parse_test_coverage(coverage_path: &str) {
+    println!("\n[--test-coverage] Parsing coverage file: {}", coverage_path);
+    
+    if let Ok(content) = fs::read_to_string(coverage_path) {
+        let coverage_re = COVERAGE_REGEX.get_or_init(|| {
+            Regex::new(r#"<coverage[^>]*line-rate="([^"]+)""#).unwrap()
+        });
+        
+        if let Some(cap) = coverage_re.captures(&content) {
+            if let Ok(line_rate) = cap.get(1).unwrap().as_str().parse::<f64>() {
+                println!("  Overall Line Coverage: {:.2}%", line_rate * 100.0);
+            } else {
+                println!("  Could not parse line-rate as a number.");
+            }
+        } else {
+            println!("  Could not find line-rate attribute in <coverage> tag.");
+        }
+    } else {
+        println!("  Failed to read coverage file: {}", coverage_path);
+    }
+}

src/analyzer.rs

@@ -2,17 +2,26 @@ use rayon::prelude::*;
 use aho_corasick::{AhoCorasick, MatchKind};
 use std::fs;
 use std::path::{Path, PathBuf};
+use regex::Regex;
+use std::sync::OnceLock;
+
+static FUNC_REGEX: OnceLock<Regex> = OnceLock::new();
+static CLASS_REGEX: OnceLock<Regex> = OnceLock::new();
 
 pub struct AnalyzerStats {
     pub path: PathBuf,
     pub complexity: f64,
+    #[allow(dead_code)]
     pub todo_count: usize,
+    #[allow(dead_code)]
     pub functions_count: usize,
+    #[allow(dead_code)]
     pub naming_violations: usize,
+    pub naming_violations_details: Vec<String>,
 }
 
 // Simplified analyzer that scans concurrently using Aho-Corasick for extreme speed
-pub fn analyze_files(paths: &[PathBuf]) -> Vec<AnalyzerStats> {
+pub fn analyze_files(paths: &[PathBuf], check_naming: bool) -> Vec<AnalyzerStats> {
     let patterns = &[
         // Complexity (0..10)
         " if ", " for ", " while ", " case ", " catch ", " try ", " except ", "&&", "||", "?:",
@@ -30,15 +39,15 @@ pub fn analyze_files(paths: &[PathBuf]) -> Vec<AnalyzerStats> {
 
     paths
         .into_par_iter()
-        .filter_map(|p| analyze_file(p, &ac))
+        .filter_map(|p| analyze_file(p, &ac, check_naming))
         .collect()
 }
 
 fn is_word_character(b: u8) -> bool {
     b.is_ascii_alphanumeric() || b == b'_'
 }
 
-fn analyze_file(path: &Path, ac: &AhoCorasick) -> Option<AnalyzerStats> {
+fn analyze_file(path: &Path, ac: &AhoCorasick, check_naming: bool) -> Option<AnalyzerStats> {
     let content = fs::read_to_string(path).ok()?;
 
     let mut complexity = 0.0;
@@ -77,13 +86,118 @@ fn analyze_file(path: &Path, ac: &AhoCorasick) -> Option<AnalyzerStats> {
         }
     }
 
-    let naming_violations = 0;
+    let mut naming_violations_details = Vec::new();
+    
+    if check_naming {
+        let func_re = FUNC_REGEX.get_or_init(|| Regex::new(r"(?:fn|def|function)\s+([a-zA-Z0-9_]+)").unwrap());
+        let class_re = CLASS_REGEX.get_or_init(|| Regex::new(r"class\s+([a-zA-Z0-9_]+)").unwrap());
+        
+        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+        let is_rust_or_py = ext == "rs" || ext == "py";
+        
+        for cap in func_re.captures_iter(&content) {
+            if let Some(m) = cap.get(1) {
+                let name = m.as_str();
+                if is_rust_or_py {
+                    // Check snake_case (lowercase, digits, underscores)
+                    if !name.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_') {
+                        naming_violations_details.push(format!("Function '{}' in {:?} should be snake_case", name, path));
+                    }
+                }
+            }
+        }
+        
+        for cap in class_re.captures_iter(&content) {
+            if let Some(m) = cap.get(1) {
+                let name = m.as_str();
+                // Check PascalCase (starts with uppercase)
+                if !name.chars().next().map_or(false, |c| c.is_ascii_uppercase()) {
+                    naming_violations_details.push(format!("Class '{}' in {:?} should be PascalCase", name, path));
+                }
+            }
+        }
+    }
+    
+    let naming_violations = naming_violations_details.len();
 
     Some(AnalyzerStats {
         path: path.to_path_buf(),
         complexity,
         todo_count,
         functions_count,
         naming_violations,
+        naming_violations_details,
     })
 }
+
+pub fn find_deadcode(paths: &[PathBuf]) -> Vec<String> {
+    let func_re = FUNC_REGEX.get_or_init(|| Regex::new(r"(?:fn|def|function)\s+([a-zA-Z0-9_]+)").unwrap());
+    
+    // Pass 1: Extract all function names
+    let mut all_functions: Vec<String> = paths.into_par_iter()
+        .filter_map(|path| {
+            if let Ok(content) = fs::read_to_string(path) {
+                let mut local_funcs = Vec::new();
+                for cap in func_re.captures_iter(&content) {
+                    if let Some(m) = cap.get(1) {
+                        local_funcs.push(m.as_str().to_string());
+                    }
+                }
+                Some(local_funcs)
+            } else {
+                None
+            }
+        })
+        .flatten()
+        .collect();
+        
+    all_functions.sort();
+    all_functions.dedup();
+    
+    if all_functions.is_empty() {
+        return Vec::new();
+    }
+    
+    // Pass 2: Count occurrences
+    let ac = aho_corasick::AhoCorasickBuilder::new()
+        .match_kind(MatchKind::Standard)
+        .build(&all_functions)
+        .unwrap();
+        
+    let counts = paths.into_par_iter().map(|path| {
+        let mut local_counts = vec![0usize; all_functions.len()];
+        if let Ok(content) = fs::read_to_string(path) {
+            let bytes = content.as_bytes();
+            for mat in ac.find_iter(&content) {
+                let start = mat.start();
+                let end = mat.end();
+                
+                let prev_ok = start == 0 || !is_word_character(bytes[start - 1]);
+                let next_ok = end == bytes.len() || !is_word_character(bytes[end]);
+                
+                if prev_ok && next_ok {
+                    local_counts[mat.pattern().as_usize()] += 1;
+                }
+            }
+        }
+        local_counts
+    }).reduce(
+        || vec![0usize; all_functions.len()],
+        |mut a, b| {
+            for (i, v) in b.iter().enumerate() {
+                a[i] += v;
+            }
+            a
+        }
+    );
+    
+    let mut deadcode = Vec::new();
+    for (i, count) in counts.iter().enumerate() {
+        if *count == 1 {
+            deadcode.push(all_functions[i].clone());
+        }
+    }
+    
+    deadcode
+}
+