zarz 0.3.4-alpha → 0.3.5-alpha

package/src/fs_ops.rs

@@ -1,117 +0,0 @@
-use anyhow::{Context, Result};
-use std::path::{Path, PathBuf};
-use tokio::fs;
-use walkdir::WalkDir;
-
-pub struct FileSystemOps;
-
-impl FileSystemOps {
-    pub async fn create_file(path: &Path, content: &str) -> Result<()> {
-        if let Some(parent) = path.parent() {
-            fs::create_dir_all(parent)
-                .await
-                .with_context(|| format!("Failed to create parent directories for {}", path.display()))?;
-        }
-
-        fs::write(path, content)
-            .await
-            .with_context(|| format!("Failed to write file {}", path.display()))?;
-
-        Ok(())
-    }
-
-    #[allow(dead_code)]
-    pub async fn delete_file(path: &Path) -> Result<()> {
-        fs::remove_file(path)
-            .await
-            .with_context(|| format!("Failed to delete file {}", path.display()))?;
-
-        Ok(())
-    }
-
-    #[allow(dead_code)]
-    pub async fn rename_file(from: &Path, to: &Path) -> Result<()> {
-        if let Some(parent) = to.parent() {
-            fs::create_dir_all(parent)
-                .await
-                .with_context(|| format!("Failed to create parent directories for {}", to.display()))?;
-        }
-
-        fs::rename(from, to)
-            .await
-            .with_context(|| format!("Failed to rename {} to {}", from.display(), to.display()))?;
-
-        Ok(())
-    }
-
-    #[allow(dead_code)]
-    pub async fn create_directory(path: &Path) -> Result<()> {
-        fs::create_dir_all(path)
-            .await
-            .with_context(|| format!("Failed to create directory {}", path.display()))?;
-
-        Ok(())
-    }
-
-    pub async fn read_file(path: &Path) -> Result<String> {
-        fs::read_to_string(path)
-            .await
-            .with_context(|| format!("Failed to read file {}", path.display()))
-    }
-
-    pub async fn file_exists(path: &Path) -> bool {
-        fs::metadata(path).await.is_ok()
-    }
-
-    #[allow(dead_code)]
-    pub fn list_files(root: &Path, pattern: Option<&str>) -> Result<Vec<PathBuf>> {
-        let mut files = Vec::new();
-
-        for entry in WalkDir::new(root)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            if entry.file_type().is_file() {
-                let path = entry.path();
-
-                if let Some(pattern) = pattern {
-                    if let Some(file_name) = path.file_name() {
-                        if file_name.to_string_lossy().contains(pattern) {
-                            files.push(path.to_path_buf());
-                        }
-                    }
-                } else {
-                    files.push(path.to_path_buf());
-                }
-            }
-        }
-
-        Ok(files)
-    }
-
-    #[allow(dead_code)]
-    pub fn get_directory_structure(root: &Path, max_depth: Option<usize>) -> Result<String> {
-        let mut output = String::new();
-        let max_depth = max_depth.unwrap_or(3);
-
-        for entry in WalkDir::new(root)
-            .max_depth(max_depth)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            let depth = entry.depth();
-            let indent = "  ".repeat(depth);
-            let name = entry.file_name().to_string_lossy();
-
-            if entry.file_type().is_dir() {
-                output.push_str(&format!("{}{}/\n", indent, name));
-            } else {
-                output.push_str(&format!("{}{}\n", indent, name));
-            }
-        }
-
-        Ok(output)
-    }
-}

package/src/intelligence/context.rs

@@ -1,143 +0,0 @@
-use anyhow::Result;
-use regex::Regex;
-use std::collections::HashSet;
-use std::path::{Path, PathBuf};
-use walkdir::WalkDir;
-
-pub struct ContextBuilder;
-
-impl ContextBuilder {
-    pub fn build_context(root: &Path, query: &str) -> Result<Vec<PathBuf>> {
-        let keywords = Self::extract_keywords(query);
-        let mut relevant_files = Vec::new();
-        let mut scores: Vec<(PathBuf, usize)> = Vec::new();
-
-        for entry in WalkDir::new(root)
-            .max_depth(10)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            if entry.file_type().is_file() {
-                let path = entry.path();
-
-                if Self::should_skip(path) {
-                    continue;
-                }
-
-                if let Ok(content) = std::fs::read_to_string(path) {
-                    let score = Self::calculate_relevance(&content, &keywords);
-
-                    if score > 0 {
-                        scores.push((path.to_path_buf(), score));
-                    }
-                }
-            }
-        }
-
-        scores.sort_by(|a, b| b.1.cmp(&a.1));
-
-        for (path, _) in scores.iter().take(5) {
-            relevant_files.push(path.clone());
-        }
-
-        Ok(relevant_files)
-    }
-
-    fn extract_keywords(query: &str) -> HashSet<String> {
-        let re = Regex::new(r"\b[a-zA-Z_][a-zA-Z0-9_]{2,}\b").unwrap();
-        let mut keywords = HashSet::new();
-
-        for cap in re.find_iter(query) {
-            let word = cap.as_str().to_lowercase();
-            if !Self::is_common_word(&word) {
-                keywords.insert(word);
-            }
-        }
-
-        keywords
-    }
-
-    fn calculate_relevance(content: &str, keywords: &HashSet<String>) -> usize {
-        let content_lower = content.to_lowercase();
-        let mut score = 0;
-
-        for keyword in keywords {
-            let count = content_lower.matches(keyword.as_str()).count();
-            score += count * 10;
-        }
-
-        score
-    }
-
-    fn should_skip(path: &Path) -> bool {
-        let path_str = path.to_string_lossy();
-
-        if path_str.contains("target/")
-            || path_str.contains(".git/")
-            || path_str.contains("node_modules/")
-            || path_str.contains(".vscode/")
-        {
-            return true;
-        }
-
-        if let Some(ext) = path.extension() {
-            let ext_str = ext.to_string_lossy();
-            if ext_str == "lock"
-                || ext_str == "json"
-                || ext_str == "md"
-                || ext_str == "txt"
-                || ext_str == "yml"
-                || ext_str == "yaml"
-            {
-                return true;
-            }
-        }
-
-        false
-    }
-
-    fn is_common_word(word: &str) -> bool {
-        matches!(
-            word,
-            "the" | "and"
-                | "for"
-                | "are"
-                | "but"
-                | "not"
-                | "you"
-                | "all"
-                | "can"
-                | "her"
-                | "was"
-                | "one"
-                | "our"
-                | "out"
-                | "day"
-                | "get"
-                | "has"
-                | "him"
-                | "his"
-                | "how"
-                | "let"
-                | "may"
-                | "new"
-                | "now"
-                | "old"
-                | "see"
-                | "try"
-                | "use"
-                | "way"
-                | "who"
-                | "boy"
-                | "did"
-                | "its"
-                | "say"
-                | "she"
-                | "too"
-                | "any"
-                | "add"
-                | "set"
-        )
-    }
-}

package/src/intelligence/mod.rs

@@ -1,60 +0,0 @@
-mod rust_parser;
-mod symbol_search;
-mod context;
-
-pub use rust_parser::RustParser;
-pub use symbol_search::SymbolSearcher;
-pub use context::ContextBuilder;
-
-use anyhow::Result;
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, Clone)]
-pub struct Symbol {
-    pub name: String,
-    pub kind: SymbolKind,
-    pub file: PathBuf,
-    #[allow(dead_code)]
-    pub line: usize,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum SymbolKind {
-    Function,
-    Struct,
-    Enum,
-    Trait,
-    Impl,
-    Module,
-    Constant,
-    Static,
-}
-
-#[derive(Debug)]
-pub struct ProjectIntelligence {
-    root: PathBuf,
-}
-
-impl ProjectIntelligence {
-    pub fn new(root: PathBuf) -> Self {
-        Self { root }
-    }
-
-    pub fn find_symbol(&self, name: &str) -> Result<Vec<Symbol>> {
-        SymbolSearcher::search(&self.root, name)
-    }
-
-    #[allow(dead_code)]
-    pub fn get_file_symbols(&self, file: &Path) -> Result<Vec<Symbol>> {
-        RustParser::parse_file(file)
-    }
-
-    pub fn get_relevant_context(&self, query: &str) -> Result<Vec<PathBuf>> {
-        ContextBuilder::build_context(&self.root, query)
-    }
-
-    #[allow(dead_code)]
-    pub fn analyze_dependencies(&self) -> Result<Vec<String>> {
-        RustParser::extract_dependencies(&self.root)
-    }
-}

package/src/intelligence/rust_parser.rs

@@ -1,141 +0,0 @@
-use super::{Symbol, SymbolKind};
-use anyhow::{Context, Result};
-use std::path::{Path, PathBuf};
-use syn::{visit::Visit, Item};
-
-pub struct RustParser;
-
-impl RustParser {
-    pub fn parse_file(path: &Path) -> Result<Vec<Symbol>> {
-        let content = std::fs::read_to_string(path)
-            .with_context(|| format!("Failed to read file {}", path.display()))?;
-
-        let syntax = syn::parse_file(&content)
-            .with_context(|| format!("Failed to parse Rust file {}", path.display()))?;
-
-        let mut visitor = SymbolVisitor {
-            symbols: Vec::new(),
-            file: path.to_path_buf(),
-        };
-
-        visitor.visit_file(&syntax);
-
-        Ok(visitor.symbols)
-    }
-
-    #[allow(dead_code)]
-    pub fn extract_dependencies(root: &Path) -> Result<Vec<String>> {
-        let cargo_path = root.join("Cargo.toml");
-
-        if !cargo_path.exists() {
-            return Ok(Vec::new());
-        }
-
-        let content = std::fs::read_to_string(&cargo_path)
-            .context("Failed to read Cargo.toml")?;
-
-        let toml: toml::Value = toml::from_str(&content)
-            .context("Failed to parse Cargo.toml")?;
-
-        let mut deps = Vec::new();
-
-        if let Some(dependencies) = toml.get("dependencies") {
-            if let Some(table) = dependencies.as_table() {
-                for (name, _) in table {
-                    deps.push(name.clone());
-                }
-            }
-        }
-
-        Ok(deps)
-    }
-}
-
-struct SymbolVisitor {
-    symbols: Vec<Symbol>,
-    file: PathBuf,
-}
-
-impl<'ast> Visit<'ast> for SymbolVisitor {
-    fn visit_item(&mut self, item: &'ast Item) {
-        match item {
-            Item::Fn(func) => {
-                let name = func.sig.ident.to_string();
-                self.symbols.push(Symbol {
-                    name,
-                    kind: SymbolKind::Function,
-                    file: self.file.clone(),
-                    line: 0,
-                });
-            }
-            Item::Struct(s) => {
-                let name = s.ident.to_string();
-                self.symbols.push(Symbol {
-                    name,
-                    kind: SymbolKind::Struct,
-                    file: self.file.clone(),
-                    line: 0,
-                });
-            }
-            Item::Enum(e) => {
-                let name = e.ident.to_string();
-                self.symbols.push(Symbol {
-                    name,
-                    kind: SymbolKind::Enum,
-                    file: self.file.clone(),
-                    line: 0,
-                });
-            }
-            Item::Trait(t) => {
-                let name = t.ident.to_string();
-                self.symbols.push(Symbol {
-                    name,
-                    kind: SymbolKind::Trait,
-                    file: self.file.clone(),
-                    line: 0,
-                });
-            }
-            Item::Impl(impl_item) => {
-                if let Some((_, path, _)) = &impl_item.trait_ {
-                    let name = quote::quote!(#path).to_string();
-                    self.symbols.push(Symbol {
-                        name,
-                        kind: SymbolKind::Impl,
-                        file: self.file.clone(),
-                        line: 0,
-                    });
-                }
-            }
-            Item::Mod(m) => {
-                let name = m.ident.to_string();
-                self.symbols.push(Symbol {
-                    name,
-                    kind: SymbolKind::Module,
-                    file: self.file.clone(),
-                    line: 0,
-                });
-            }
-            Item::Const(c) => {
-                let name = c.ident.to_string();
-                self.symbols.push(Symbol {
-                    name,
-                    kind: SymbolKind::Constant,
-                    file: self.file.clone(),
-                    line: 0,
-                });
-            }
-            Item::Static(s) => {
-                let name = s.ident.to_string();
-                self.symbols.push(Symbol {
-                    name,
-                    kind: SymbolKind::Static,
-                    file: self.file.clone(),
-                    line: 0,
-                });
-            }
-            _ => {}
-        }
-
-        syn::visit::visit_item(self, item);
-    }
-}

package/src/intelligence/symbol_search.rs

@@ -1,97 +0,0 @@
-use super::{RustParser, Symbol};
-use anyhow::Result;
-use std::path::Path;
-use walkdir::WalkDir;
-
-pub struct SymbolSearcher;
-
-impl SymbolSearcher {
-    pub fn search(root: &Path, name: &str) -> Result<Vec<Symbol>> {
-        let mut results = Vec::new();
-
-        for entry in WalkDir::new(root)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            if entry.file_type().is_file() {
-                let path = entry.path();
-
-                if let Some(ext) = path.extension() {
-                    if ext == "rs" {
-                        if let Ok(symbols) = RustParser::parse_file(path) {
-                            for symbol in symbols {
-                                if symbol.name.contains(name) {
-                                    results.push(symbol);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(results)
-    }
-
-    #[allow(dead_code)]
-    pub fn search_exact(root: &Path, name: &str) -> Result<Vec<Symbol>> {
-        let mut results = Vec::new();
-
-        for entry in WalkDir::new(root)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            if entry.file_type().is_file() {
-                let path = entry.path();
-
-                if let Some(ext) = path.extension() {
-                    if ext == "rs" {
-                        if let Ok(symbols) = RustParser::parse_file(path) {
-                            for symbol in symbols {
-                                if symbol.name == name {
-                                    results.push(symbol);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(results)
-    }
-
-    #[allow(dead_code)]
-    pub fn find_references(root: &Path, symbol_name: &str) -> Result<Vec<(String, usize)>> {
-        let mut references = Vec::new();
-
-        for entry in WalkDir::new(root)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            if entry.file_type().is_file() {
-                let path = entry.path();
-
-                if let Some(ext) = path.extension() {
-                    if ext == "rs" {
-                        if let Ok(content) = std::fs::read_to_string(path) {
-                            for (line_num, line) in content.lines().enumerate() {
-                                if line.contains(symbol_name) {
-                                    references.push((
-                                        format!("{}:{}", path.display(), line_num + 1),
-                                        line_num + 1,
-                                    ));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(references)
-    }
-}