fix(core): replace temporary placeholders

vinhnx · vinhnx · commit b219d7edffec · 2025-09-15T15:10:56.000+07:00
diff --git a/docs/user-guide/commands.md b/docs/user-guide/commands.md
@@ -59,7 +59,7 @@ Ask: Search for TODO|FIXME across the repo with 2 lines of context in .rs files
 - `list_files(path, max_items?, include_hidden?)`
 - `read_file(path, max_bytes?)`
 - `write_file(path, content, mode?)` — mode: `overwrite`, `append`, or `skip_if_exists`
-- `edit_file(path, old_str, new_str)` — tolerant to whitespace differences
+- `edit_file(path, old_str, new_str)` — tolerant to whitespace differences and detects rename conflicts
 
 ## stats (session metrics)
 
@@ -72,3 +72,4 @@ tool.
 - The agent respects `.vtagentgitignore` to exclude files from search and I/O.
 - Prefer `rp_search` for fast, focused searches with glob filters and context.
 - Ask for “N lines of context” when searching to understand usage in-place.
+- Shell commands are filtered by allow/deny lists and can be extended via `VTAGENT_<AGENT>_COMMANDS_*` environment variables.
diff --git a/prompts/system.md b/prompts/system.md
@@ -20,9 +20,9 @@ Your capabilities:
 Within this context, VTAgent refers to the open-source agentic coding interface created by vinhnx, not any other coding tools or models.
 
 ## AVAILABLE TOOLS
-- **File Operations**: list_files, read_file, write_file, edit_file
+- **File Operations**: list_files, read_file, write_file, edit_file (rename conflict detection and safe writes)
 - **Search & Analysis**: grep_search (modes: exact, fuzzy, multi, similarity) and ast_grep_search
-- **Terminal Access**: run_terminal_cmd (modes: terminal, pty, streaming)
+- **Terminal Access**: run_terminal_cmd (modes: terminal, pty, streaming) with per-agent allow/deny policies
 
 ### Advanced Code Analysis
 VTAgent provides intelligent code analysis tools that understand code structure:
diff --git a/scripts/test_tools_e2e.sh b/scripts/test_tools_e2e.sh
@@ -44,12 +44,15 @@ test_tool_directly() {
 
     echo -e "\n${YELLOW}Testing $tool_name tool directly${NC}"
 
-    # Try to build and test the tool
+    # Build and execute the tool through the binary
     if cargo build --bin vtagent >/dev/null 2>&1; then
-        # If binary builds, we could test it directly
-        # For now, just check if it compiles
-        echo -e "${GREEN}Tool compiles successfully${NC}"
-        TESTS_PASSED=$((TESTS_PASSED + 1))
+        output=$(cargo run --quiet --bin vtagent -- "$tool_name" "$test_input" 2>/dev/null)
+        if echo "$output" | grep -q "$expected_contains"; then
+            echo -e "${GREEN}Tool output verified${NC}"
+            TESTS_PASSED=$((TESTS_PASSED + 1))
+        else
+            echo -e "${RED}❌ Unexpected tool output${NC}"
+        fi
     else
         echo -e "${RED}❌ Tool compilation failed${NC}"
     fi
diff --git a/src/cli/init.rs b/src/cli/init.rs
@@ -1,6 +1,9 @@
-use anyhow::Result;
+use crate::cli::handle_chat_command;
+use anyhow::{Context, Result};
 use console::style;
 use std::path::Path;
+use vtagent_core::config::loader::VTAgentConfig;
+use vtagent_core::config::types::AgentConfig as CoreAgentConfig;
 
 /// Handle the init command
 pub async fn handle_init_command(workspace: &Path, force: bool, run: bool) -> Result<()> {
@@ -12,15 +15,21 @@ pub async fn handle_init_command(workspace: &Path, force: bool, run: bool) -> Re
     println!("Force overwrite: {}", force);
     println!("Run after init: {}", run);
 
-    // Configuration initialization implementation
-    // This would create the vtagent.toml and .vtagentgitignore files
-    println!("Configuration files created successfully!");
+    // Bootstrap configuration files in the workspace
+    VTAgentConfig::bootstrap_project(workspace, force)
+        .with_context(|| "failed to initialize configuration files")?;
 
     if run {
-        println!("Running vtagent after initialization...");
-        // This would actually run the agent
-        // For now, we'll just print a message
-        println!("vtagent is now running!");
+        // After successful initialization, launch a chat session using default config
+        let config = CoreAgentConfig {
+            model: String::new(),
+            api_key: String::new(),
+            workspace: workspace.to_path_buf(),
+            verbose: false,
+        };
+        handle_chat_command(&config, false)
+            .await
+            .with_context(|| "failed to start chat session")?;
     }
 
     Ok(())
diff --git a/tests/refactoring_engine_test.rs b/tests/refactoring_engine_test.rs
@@ -0,0 +1,72 @@
+use std::fs;
+use tempfile::tempdir;
+use vtagent_core::tools::tree_sitter::analyzer::Position;
+use vtagent_core::tools::tree_sitter::refactoring::{
+    CodeChange, RefactoringEngine, RefactoringKind, RefactoringOperation, TextRange,
+};
+
+fn make_range(offset: usize, len: usize) -> TextRange {
+    TextRange {
+        start: Position {
+            row: 0,
+            column: offset,
+            byte_offset: offset,
+        },
+        end: Position {
+            row: 0,
+            column: offset + len,
+            byte_offset: offset + len,
+        },
+    }
+}
+
+#[test]
+fn rename_conflict_detected() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("conflict.rs");
+    let content = "let x = 1;\nlet y = 2;\nprintln!(\"{}\", x);\n";
+    fs::write(&file, content).unwrap();
+    let start = content.find("x = 1").unwrap();
+    let range = make_range(start, 1);
+    let op = RefactoringOperation {
+        kind: RefactoringKind::Rename,
+        description: "rename x to y".to_string(),
+        changes: vec![CodeChange {
+            file_path: file.to_string_lossy().into(),
+            old_range: range,
+            new_text: "y".to_string(),
+            description: String::new(),
+        }],
+        preview: vec![],
+    };
+    let mut engine = RefactoringEngine::new();
+    let result = engine.apply_refactoring(&op).unwrap();
+    assert!(!result.success);
+    assert!(!result.conflicts.is_empty());
+}
+
+#[test]
+fn rename_applies_change() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("rename.rs");
+    let content = "let x = 1;\nprintln!(\"{}\", x);\n";
+    fs::write(&file, content).unwrap();
+    let start = content.find("x = 1").unwrap();
+    let range = make_range(start, 1);
+    let op = RefactoringOperation {
+        kind: RefactoringKind::Rename,
+        description: "rename x to z".to_string(),
+        changes: vec![CodeChange {
+            file_path: file.to_string_lossy().into(),
+            old_range: range,
+            new_text: "z".to_string(),
+            description: String::new(),
+        }],
+        preview: vec![],
+    };
+    let mut engine = RefactoringEngine::new();
+    let result = engine.apply_refactoring(&op).unwrap();
+    assert!(result.success);
+    let updated = fs::read_to_string(&file).unwrap();
+    assert!(updated.contains("let z = 1"));
+}
diff --git a/vtagent-core/src/core/agent/runner.rs b/vtagent-core/src/core/agent/runner.rs
@@ -1039,8 +1039,16 @@ impl AgentRunner {
                 String::new()
             };
 
-            // For now, use the global allow/deny lists (per-agent overrides can be added similarly)
-            for pat in &cfg.commands.deny_regex {
+            let agent_prefix = format!(
+                "VTAGENT_{}_COMMANDS_",
+                self.agent_type.to_string().to_uppercase()
+            );
+
+            let mut deny_regex = cfg.commands.deny_regex.clone();
+            if let Ok(extra) = std::env::var(format!("{}DENY_REGEX", agent_prefix)) {
+                deny_regex.extend(extra.split(',').map(|s| s.trim().to_string()));
+            }
+            for pat in &deny_regex {
                 if regex::Regex::new(pat)
                     .ok()
                     .map(|re| re.is_match(&cmd_text))
@@ -1049,7 +1057,12 @@ impl AgentRunner {
                     return Err(anyhow!("Shell command denied by regex: {}", pat));
                 }
             }
-            for pat in &cfg.commands.deny_glob {
+
+            let mut deny_glob = cfg.commands.deny_glob.clone();
+            if let Ok(extra) = std::env::var(format!("{}DENY_GLOB", agent_prefix)) {
+                deny_glob.extend(extra.split(',').map(|s| s.trim().to_string()));
+            }
+            for pat in &deny_glob {
                 let re = format!("^{}$", regex::escape(pat).replace(r"\*", ".*"));
                 if regex::Regex::new(&re)
                     .ok()
diff --git a/vtagent-core/src/llm/providers/anthropic.rs b/vtagent-core/src/llm/providers/anthropic.rs
@@ -118,17 +118,29 @@ impl AnthropicProvider {
                 "content": msg.content
             });
 
-            // Add tool_call_id for tool responses if present
-            // This helps maintain context for tool call chains
+            // Tool responses must be represented as tool_result content in a user message
             if msg.role == MessageRole::Tool {
-                if let Some(_tool_call_id) = &msg.tool_call_id {
-                    // Note: Anthropic doesn't use tool_call_id in the same way as OpenAI
-                    // but we can include it as metadata in the content or ignore it
-                    // For now, we'll include the tool response content as-is
+                if let Some(tool_call_id) = &msg.tool_call_id {
+                    messages.push(json!({
+                        "role": "user",
+                        "content": [{
+                            "type": "tool_result",
+                            "tool_use_id": tool_call_id,
+                            "content": [
+                                {"type": "text", "text": msg.content}
+                            ]
+                        }]
+                    }));
+                } else {
+                    // Fallback: treat as plain user message if id missing
+                    messages.push(json!({
+                        "role": "user",
+                        "content": [{"type": "text", "text": msg.content}]
+                    }));
                 }
+            } else {
+                messages.push(message);
             }
-
-            messages.push(message);
         }
 
         let mut anthropic_request = json!({
diff --git a/vtagent-core/src/llm/providers/gemini.rs b/vtagent-core/src/llm/providers/gemini.rs
@@ -103,6 +103,19 @@ impl GeminiProvider {
     fn convert_to_gemini_format(&self, request: &LLMRequest) -> Result<Value, LLMError> {
         let mut contents = Vec::new();
 
+        // Map tool_call_id to function name from previous assistant messages
+        use std::collections::HashMap;
+        let mut call_map: HashMap<String, String> = HashMap::new();
+        for message in &request.messages {
+            if message.role == MessageRole::Assistant {
+                if let Some(tool_calls) = &message.tool_calls {
+                    for call in tool_calls {
+                        call_map.insert(call.id.clone(), call.function.name.clone());
+                    }
+                }
+            }
+        }
+
         for message in &request.messages {
             // Skip system messages - they should be handled as systemInstruction
             if message.role == MessageRole::System {
@@ -141,14 +154,14 @@ impl GeminiProvider {
                 // For tool responses, we need to construct a functionResponse
                 // The tool_call_id should help us match this to the original function call
                 if let Some(tool_call_id) = &message.tool_call_id {
-                    // We need to extract the function name from the tool_call_id or content
-                    // For now, we'll try to parse it from the context or use a generic approach
+                    let func_name = call_map
+                        .get(tool_call_id)
+                        .cloned()
+                        .unwrap_or_else(|| tool_call_id.clone());
                     parts.push(json!({
                         "functionResponse": {
-                            "name": tool_call_id, // This should be the function name
-                            "response": {
-                                "content": message.content
-                            }
+                            "name": func_name,
+                            "response": {"content": message.content}
                         }
                     }));
                 } else {
diff --git a/vtagent-core/src/tools/registry.rs b/vtagent-core/src/tools/registry.rs
@@ -8,21 +8,21 @@ use super::file_ops::FileOpsTool;
 use super::search::SearchTool;
 use super::simple_search::SimpleSearchTool;
 use super::traits::Tool;
+use crate::config::PtyConfig;
 use crate::config::constants::tools;
 use crate::config::loader::ConfigManager;
 use crate::config::types::CapabilityLevel;
-use crate::config::PtyConfig;
 use crate::gemini::FunctionDeclaration;
 use crate::tool_policy::{ToolPolicy, ToolPolicyManager};
 use crate::tools::ast_grep::AstGrepEngine;
 use crate::tools::grep_search::{GrepSearchManager, GrepSearchResult};
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use regex::Regex;
 use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use std::path::PathBuf;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 /// Enhanced error handling for tool execution following Anthropic's best practices
 /// Provides detailed error information and recovery suggestions
@@ -737,8 +737,12 @@ impl ToolRegistry {
             String::new()
         };
 
+        let mut deny_regex = cfg.commands.deny_regex.clone();
+        if let Ok(extra) = std::env::var("VTAGENT_COMMANDS_DENY_REGEX") {
+            deny_regex.extend(extra.split(',').map(|s| s.trim().to_string()));
+        }
         // Deny regex
-        for pat in &cfg.commands.deny_regex {
+        for pat in &deny_regex {
             if Regex::new(pat)
                 .ok()
                 .map(|re| re.is_match(&cmd_text))
@@ -747,8 +751,12 @@ impl ToolRegistry {
                 return Err(anyhow!("Command denied by regex policy: {}", pat));
             }
         }
+        let mut deny_glob = cfg.commands.deny_glob.clone();
+        if let Ok(extra) = std::env::var("VTAGENT_COMMANDS_DENY_GLOB") {
+            deny_glob.extend(extra.split(',').map(|s| s.trim().to_string()));
+        }
         // Deny glob (convert basic * to .*)
-        for pat in &cfg.commands.deny_glob {
+        for pat in &deny_glob {
             let re = format!("^{}$", regex::escape(pat).replace(r"\*", ".*"));
             if Regex::new(&re)
                 .ok()
@@ -759,17 +767,28 @@ impl ToolRegistry {
             }
         }
         // Exact deny list
-        for d in &cfg.commands.deny_list {
+        let mut deny_list = cfg.commands.deny_list.clone();
+        if let Ok(extra) = std::env::var("VTAGENT_COMMANDS_DENY_LIST") {
+            deny_list.extend(extra.split(',').map(|s| s.trim().to_string()));
+        }
+        for d in &deny_list {
             if cmd_text.starts_with(d) {
                 return Err(anyhow!("Command denied by policy: {}", d));
             }
         }
 
         // Allow: if allow_regex/glob present, require one match
-        let mut allow_ok =
-            cfg.commands.allow_regex.is_empty() && cfg.commands.allow_glob.is_empty();
+        let mut allow_regex = cfg.commands.allow_regex.clone();
+        if let Ok(extra) = std::env::var("VTAGENT_COMMANDS_ALLOW_REGEX") {
+            allow_regex.extend(extra.split(',').map(|s| s.trim().to_string()));
+        }
+        let mut allow_glob = cfg.commands.allow_glob.clone();
+        if let Ok(extra) = std::env::var("VTAGENT_COMMANDS_ALLOW_GLOB") {
+            allow_glob.extend(extra.split(',').map(|s| s.trim().to_string()));
+        }
+        let mut allow_ok = allow_regex.is_empty() && allow_glob.is_empty();
         if !allow_ok {
-            if cfg.commands.allow_regex.iter().any(|pat| {
+            if allow_regex.iter().any(|pat| {
                 Regex::new(pat)
                     .ok()
                     .map(|re| re.is_match(&cmd_text))
@@ -778,7 +797,7 @@ impl ToolRegistry {
                 allow_ok = true;
             }
             if !allow_ok
-                && cfg.commands.allow_glob.iter().any(|pat| {
+                && allow_glob.iter().any(|pat| {
                     let re = format!("^{}$", regex::escape(pat).replace(r"\*", ".*"));
                     Regex::new(&re)
                         .ok()
@@ -791,12 +810,12 @@ impl ToolRegistry {
         }
         if !allow_ok {
             // Fall back to exact allow_list if provided
-            if !cfg.commands.allow_list.is_empty() {
-                allow_ok = cfg
-                    .commands
-                    .allow_list
-                    .iter()
-                    .any(|p| cmd_text.starts_with(p));
+            let mut allow_list = cfg.commands.allow_list.clone();
+            if let Ok(extra) = std::env::var("VTAGENT_COMMANDS_ALLOW_LIST") {
+                allow_list.extend(extra.split(',').map(|s| s.trim().to_string()));
+            }
+            if !allow_list.is_empty() {
+                allow_ok = allow_list.iter().any(|p| cmd_text.starts_with(p));
             }
         }
         if !allow_ok {
diff --git a/vtagent-core/src/tools/tree_sitter/navigation.rs b/vtagent-core/src/tools/tree_sitter/navigation.rs
diff --git a/vtagent-core/src/tools/tree_sitter/refactoring.rs b/vtagent-core/src/tools/tree_sitter/refactoring.rs
diff --git a/vtagent-core/tests/config_loader_test.rs b/vtagent-core/tests/config_loader_test.rs
diff --git a/vtagent-core/tests/project_test.rs b/vtagent-core/tests/project_test.rs
