zarz 0.3.1-alpha

package/src/executor.rs

@@ -0,0 +1,164 @@
+use anyhow::{Context, Result};
+use std::process::Stdio;
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::process::Command;
+
+pub struct CommandExecutor;
+
+#[derive(Debug)]
+pub struct CommandResult {
+    pub stdout: String,
+    pub stderr: String,
+    pub exit_code: i32,
+    pub success: bool,
+}
+
+impl CommandExecutor {
+    pub async fn execute(command: &str) -> Result<CommandResult> {
+        let (shell, flag) = if cfg!(target_os = "windows") {
+            ("cmd", "/C")
+        } else {
+            ("sh", "-c")
+        };
+
+        let mut child = Command::new(shell)
+            .arg(flag)
+            .arg(command)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .with_context(|| format!("Failed to execute command: {}", command))?;
+
+        let stdout = child
+            .stdout
+            .take()
+            .context("Failed to capture stdout")?;
+
+        let stderr = child
+            .stderr
+            .take()
+            .context("Failed to capture stderr")?;
+
+        let mut stdout_lines = BufReader::new(stdout).lines();
+        let mut stderr_lines = BufReader::new(stderr).lines();
+
+        let stdout_handle = tokio::spawn(async move {
+            let mut output = String::new();
+            while let Ok(Some(line)) = stdout_lines.next_line().await {
+                output.push_str(&line);
+                output.push('\n');
+            }
+            output
+        });
+
+        let stderr_handle = tokio::spawn(async move {
+            let mut output = String::new();
+            while let Ok(Some(line)) = stderr_lines.next_line().await {
+                output.push_str(&line);
+                output.push('\n');
+            }
+            output
+        });
+
+        let stdout_output = stdout_handle
+            .await
+            .context("Failed to join stdout task")?;
+
+        let stderr_output = stderr_handle
+            .await
+            .context("Failed to join stderr task")?;
+
+        let status = child
+            .wait()
+            .await
+            .context("Failed to wait for command")?;
+
+        let exit_code = status.code().unwrap_or(-1);
+        let success = status.success();
+
+        Ok(CommandResult {
+            stdout: stdout_output,
+            stderr: stderr_output,
+            exit_code,
+            success,
+        })
+    }
+
+    #[allow(dead_code)]
+    pub async fn execute_streaming<F>(command: &str, mut on_output: F) -> Result<CommandResult>
+    where
+        F: FnMut(&str) + Send,
+    {
+        let (shell, flag) = if cfg!(target_os = "windows") {
+            ("cmd", "/C")
+        } else {
+            ("sh", "-c")
+        };
+
+        let mut child = Command::new(shell)
+            .arg(flag)
+            .arg(command)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .with_context(|| format!("Failed to execute command: {}", command))?;
+
+        let stdout = child
+            .stdout
+            .take()
+            .context("Failed to capture stdout")?;
+
+        let stderr = child
+            .stderr
+            .take()
+            .context("Failed to capture stderr")?;
+
+        let mut stdout_lines = BufReader::new(stdout).lines();
+        let mut stderr_lines = BufReader::new(stderr).lines();
+
+        let mut stdout_output = String::new();
+        let mut stderr_output = String::new();
+
+        loop {
+            tokio::select! {
+                result = stdout_lines.next_line() => {
+                    match result {
+                        Ok(Some(line)) => {
+                            on_output(&line);
+                            stdout_output.push_str(&line);
+                            stdout_output.push('\n');
+                        }
+                        Ok(None) => break,
+                        Err(_) => break,
+                    }
+                }
+                result = stderr_lines.next_line() => {
+                    match result {
+                        Ok(Some(line)) => {
+                            on_output(&line);
+                            stderr_output.push_str(&line);
+                            stderr_output.push('\n');
+                        }
+                        Ok(None) => {},
+                        Err(_) => {},
+                    }
+                }
+            }
+        }
+
+        let status = child
+            .wait()
+            .await
+            .context("Failed to wait for command")?;
+
+        let exit_code = status.code().unwrap_or(-1);
+        let success = status.success();
+
+        Ok(CommandResult {
+            stdout: stdout_output,
+            stderr: stderr_output,
+            exit_code,
+            success,
+        })
+    }
+}

package/src/fs_ops.rs

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,141 @@
+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);
+    }
+}