add build-in tools and easy to quit

Signed-off-by: Jintao Zhang <zhangjintao9020@gmail.com>

.kiro/specs/ctrl-d-quit/design.md

@@ -0,0 +1,156 @@
+# Design Document
+
+## Overview
+
+This feature adds support for gracefully handling Ctrl+D (EOF signal) in the `amcp agent` interactive mode. Currently, users can only exit using explicit commands like 'exit', 'quit', or 'q'. Adding Ctrl+D support provides a more natural terminal experience consistent with standard CLI tools and REPL environments.
+
+The implementation will catch the `EOFError` exception raised when users press Ctrl+D and perform the same cleanup and exit sequence as the existing exit commands.
+
+## Architecture
+
+The change is localized to the interactive loop in `src/amcp/cli.py`. The architecture follows the existing pattern:
+
+1. **Input Layer**: The `console.input()` call in the interactive loop
+2. **Exception Handling**: New `EOFError` catch block
+3. **Exit Sequence**: Reuse existing goodbye message and cleanup logic
+
+No new components or modules are required. The change integrates seamlessly with the existing conversation history persistence and session management.
+
+## Components and Interfaces
+
+### Modified Component: Interactive Loop (`src/amcp/cli.py`)
+
+**Current Implementation:**
+```python
+while True:
+    try:
+        user_input = console.input("[bold]You:[/bold] ").strip()
+        
+        if user_input.lower() in ['exit', 'quit', 'q']:
+            console.print("[green]Goodbye! 👋[/green]")
+            break
+        # ... rest of loop
+    except KeyboardInterrupt:
+        console.print("\\n[yellow]Interrupted. Type 'exit' to quit.[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+```
+
+**Modified Implementation:**
+The `EOFError` exception will be caught at the same level as `KeyboardInterrupt`, providing consistent exception handling for terminal signals.
+
+### Interface Changes
+
+No public API changes. The modification is internal to the CLI interactive loop. The behavior change is:
+
+- **Before**: Ctrl+D causes an unhandled `EOFError`, potentially crashing or displaying an error
+- **After**: Ctrl+D triggers graceful exit with goodbye message and proper cleanup
+
+## Data Models
+
+No data model changes required. The existing session management and conversation history structures remain unchanged.
+
+## Correctness Properties
+
+*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
+
+### Property 1: EOF signal triggers graceful exit
+*For any* interactive session, when an EOF signal (Ctrl+D) is received, the system should exit the interactive loop and display a goodbye message.
+**Validates: Requirements 1.1, 1.2**
+
+### Property 2: Conversation history persists on EOF exit
+*For any* interactive session with conversation history, when an EOF signal triggers exit, the conversation history should be saved before the program terminates.
+**Validates: Requirements 1.3**
+
+### Property 3: EOF exit performs same cleanup as explicit exit
+*For any* interactive session, the cleanup operations performed when exiting via EOF signal should be equivalent to the cleanup operations performed when exiting via explicit 'exit' command.
+**Validates: Requirements 1.4**
+
+### Property 4: Backward compatibility maintained
+*For any* existing exit command ('exit', 'quit', 'q'), the command should continue to function identically after EOF handling is added.
+**Validates: Requirements 1.5**
+
+## Error Handling
+
+### EOFError Handling
+
+The `EOFError` exception is raised by Python's `input()` function when it encounters an EOF signal:
+- **Unix/Linux/macOS**: Ctrl+D
+- **Windows**: Ctrl+Z followed by Enter
+
+**Handling Strategy:**
+1. Catch `EOFError` in the same try-except block as other exceptions
+2. Print goodbye message using the same format as explicit exit commands
+3. Break from the interactive loop
+4. Allow normal program termination (which triggers existing cleanup via Agent's `_save_conversation_history()`)
+
+### Edge Cases
+
+1. **EOF on empty input**: Should exit gracefully (standard behavior)
+2. **EOF mid-input**: Should exit gracefully, discarding partial input
+3. **Multiple EOF signals**: First EOF should exit; subsequent signals are irrelevant
+4. **EOF during agent processing**: Handled by existing `KeyboardInterrupt` logic (Ctrl+C), not EOF
+
+## Testing Strategy
+
+### Unit Tests
+
+Unit tests will verify the core EOF handling logic:
+
+1. **Test EOF triggers exit**: Simulate `EOFError` and verify the loop exits
+2. **Test goodbye message displayed**: Verify correct message is printed on EOF
+3. **Test backward compatibility**: Verify existing exit commands still work
+4. **Test conversation history saved**: Verify `_save_conversation_history()` is called before exit
+
+### Property-Based Tests
+
+Property-based tests will verify the universal behaviors:
+
+1. **Property 1 Test**: Generate random interactive sessions, inject EOF signal, verify graceful exit with goodbye message
+2. **Property 2 Test**: Generate random sessions with conversation history, inject EOF, verify history is persisted
+3. **Property 3 Test**: Compare cleanup operations between EOF exit and explicit exit command, verify equivalence
+4. **Property 4 Test**: Generate random exit commands from the set {'exit', 'quit', 'q'}, verify all still function correctly
+
+### Testing Framework
+
+- **Unit Testing**: pytest
+- **Property-Based Testing**: Hypothesis (Python PBT library)
+- **Mocking**: unittest.mock for simulating user input and EOF signals
+
+### Test Configuration
+
+- Property-based tests will run a minimum of 100 iterations
+- Tests will mock `console.input()` to simulate EOF without requiring actual terminal interaction
+- Tests will verify both stdout output and internal state changes
+
+## Implementation Notes
+
+### Design Decisions
+
+**Decision 1: Reuse existing exit logic**
+- **Rationale**: The existing exit commands already handle cleanup correctly. By catching `EOFError` and breaking from the loop, we leverage the same cleanup path.
+- **Alternative considered**: Implement separate cleanup function. Rejected due to code duplication and maintenance burden.
+
+**Decision 2: Same goodbye message for all exit methods**
+- **Rationale**: Consistency in user experience. Users should see the same friendly goodbye regardless of how they exit.
+- **Alternative considered**: Different message for EOF. Rejected as it adds complexity without user benefit.
+
+**Decision 3: Place EOFError handler alongside KeyboardInterrupt**
+- **Rationale**: Both are terminal signal exceptions. Grouping them improves code readability and maintainability.
+- **Alternative considered**: Separate try-except block. Rejected as it would duplicate exception handling structure.
+
+### Minimal Change Principle
+
+This design follows the principle of minimal change:
+- Single exception handler addition
+- No new functions or classes
+- No changes to data structures
+- No changes to existing exit logic
+- Estimated change: ~4 lines of code
+
+### Platform Compatibility
+
+The implementation is platform-agnostic:
+- Python's `EOFError` is raised consistently across platforms
+- The specific key combination (Ctrl+D vs Ctrl+Z) is handled by the OS and Python runtime
+- No platform-specific code required

.kiro/specs/ctrl-d-quit/requirements.md

@@ -0,0 +1,25 @@
+# Requirements Document
+
+## Introduction
+
+This feature adds support for quitting the `amcp agent` interactive mode using Ctrl+D (EOF signal) in addition to the existing `exit` command. This provides a more natural terminal experience consistent with other CLI tools.
+
+## Glossary
+
+- **Agent Interactive Mode**: The REPL (Read-Eval-Print Loop) interface where users interact with the agent through a command-line prompt
+- **EOF Signal**: End-of-File signal generated by pressing Ctrl+D on Unix-like systems or Ctrl+Z on Windows
+- **EOFError**: Python exception raised when the input() function encounters an EOF signal
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a user, I want to quit the agent interactive mode using Ctrl+D, so that I can exit quickly using standard terminal conventions.
+
+#### Acceptance Criteria
+
+1. WHEN a user presses Ctrl+D in the agent interactive mode THEN the system SHALL catch the EOFError exception and exit gracefully
+2. WHEN the system exits via Ctrl+D THEN the system SHALL display a goodbye message to the user
+3. WHEN the system exits via Ctrl+D THEN the system SHALL save the conversation history before exiting
+4. WHEN the system exits via Ctrl+D THEN the system SHALL perform the same cleanup as the existing 'exit' command
+5. THE system SHALL maintain backward compatibility with existing exit commands ('exit', 'quit', 'q')

.kiro/specs/ctrl-d-quit/tasks.md

@@ -0,0 +1,46 @@
+# Implementation Plan
+
+- [x] 1. Add EOFError handling to interactive loop
+  - Modify the interactive loop in `src/amcp/cli.py` to catch `EOFError` exception
+  - Add exception handler alongside existing `KeyboardInterrupt` handler
+  - Display goodbye message using same format as explicit exit commands
+  - Break from loop to trigger normal cleanup sequence
+  - _Requirements: 1.1, 1.2, 1.3, 1.4_
+
+- [ ] 2. Set up testing infrastructure
+  - Add pytest and hypothesis to project dependencies in `pyproject.toml`
+  - Create `tests/` directory structure
+  - Create `tests/test_cli.py` for CLI tests
+  - Set up test fixtures for mocking console input
+  - _Requirements: All (testing infrastructure)_
+
+- [ ] 3. Write property-based tests for EOF handling
+  - [ ] 3.1 Write property test for graceful exit on EOF
+    - **Property 1: EOF signal triggers graceful exit**
+    - **Validates: Requirements 1.1, 1.2**
+  
+  - [ ] 3.2 Write property test for conversation history persistence
+    - **Property 2: Conversation history persists on EOF exit**
+    - **Validates: Requirements 1.3**
+  
+  - [ ] 3.3 Write property test for cleanup equivalence
+    - **Property 3: EOF exit performs same cleanup as explicit exit**
+    - **Validates: Requirements 1.4**
+  
+  - [ ] 3.4 Write property test for backward compatibility
+    - **Property 4: Backward compatibility maintained**
+    - **Validates: Requirements 1.5**
+
+- [ ] 4. Write unit tests for EOF handling
+  - Test EOF exception is caught and handled gracefully
+  - Test goodbye message is displayed on EOF
+  - Test existing exit commands ('exit', 'quit', 'q') still work
+  - Test conversation history is saved before exit
+  - _Requirements: 1.1, 1.2, 1.3, 1.4, 1.5_
+
+- [ ] 5. Manual verification
+  - Run the agent in interactive mode and test Ctrl+D on Unix/Linux/macOS
+  - Verify goodbye message appears
+  - Verify conversation history is saved
+  - Verify existing exit commands still work
+  - _Requirements: All_

README.md

@@ -75,6 +75,8 @@ amcp mcp call --server exa --tool web_search_exa --args '{"query":"rust async"}'
 - **grep**: Search for patterns in files using ripgrep
 - **bash**: Execute bash commands for file operations and system tasks
 - **think**: Internal reasoning and planning
+- **write_file**: Write content to files (can be disabled via config)
+- **edit_file**: Edit files with search and replace (can be disabled via config)
 
 ## Config
 
@@ -101,6 +103,8 @@ base_url = "https://api.sambanova.ai/v1"
 model = "DeepSeek-V3.1-Terminus"
 api_key = "your-api-key"
 mcp_tools_enabled = true
+write_tool_enabled = true  # Enable/disable built-in write_file tool
+edit_tool_enabled = true   # Enable/disable built-in edit_file tool
 ```
 
 ## Notes

src/amcp/cli.py

@@ -229,6 +229,9 @@ def main(
                     console.print(f"[dim]Steps: {summary['steps_taken']}/{summary['max_steps']} | Tools called: {summary['tools_called']} | Session: {agent.session_id}[/dim]")
                     console.print()
                     
+                except EOFError:
+                    console.print("[green]Goodbye! 👋[/green]")
+                    break
                 except KeyboardInterrupt:
                     console.print("\\n[yellow]Interrupted. Type 'exit' to quit.[/yellow]")
                 except Exception as e:

src/amcp/config.py

@@ -40,6 +40,9 @@ class ChatConfig:
     # MCP tool exposure
     mcp_tools_enabled: Optional[bool] = None
     mcp_servers: Optional[list[str]] = None  # which servers' tools to expose; if unset, expose all configured servers
+    # Built-in file modification tools
+    write_tool_enabled: Optional[bool] = None
+    edit_tool_enabled: Optional[bool] = None
 
 
 @dataclass
@@ -61,8 +64,10 @@ _DEFAULT = {
         "tool_loop_limit": 5,
         "default_max_lines": 400,
         # "read_roots": ["."]  # optional; defaults to current working directory when unset
-"mcp_tools_enabled": True,
+        "mcp_tools_enabled": True,
         # "mcp_servers": ["exa"]  # optional; if unset, expose all configured servers
+        "write_tool_enabled": True,
+        "edit_tool_enabled": True,
     }
 }
 
@@ -89,6 +94,8 @@ def _decode_chat(raw: Mapping[str, object] | None) -> Optional[ChatConfig]:
     read_roots = raw.get("read_roots")
     mcp_tools_enabled = raw.get("mcp_tools_enabled")
     mcp_servers = raw.get("mcp_servers")
+    write_tool_enabled = raw.get("write_tool_enabled")
+    edit_tool_enabled = raw.get("edit_tool_enabled")
     return ChatConfig(
         base_url=str(base_url) if base_url is not None else None,
         model=str(model) if model is not None else None,
@@ -98,6 +105,8 @@ def _decode_chat(raw: Mapping[str, object] | None) -> Optional[ChatConfig]:
         read_roots=[str(p) for p in (read_roots or [])] if read_roots is not None else None,
         mcp_tools_enabled=bool(mcp_tools_enabled) if mcp_tools_enabled is not None else None,
         mcp_servers=[str(s) for s in (mcp_servers or [])] if mcp_servers is not None else None,
+        write_tool_enabled=bool(write_tool_enabled) if write_tool_enabled is not None else None,
+        edit_tool_enabled=bool(edit_tool_enabled) if edit_tool_enabled is not None else None,
     )
 
 
@@ -147,6 +156,10 @@ def _encode_chat(c: ChatConfig | None) -> dict | None:
         out["mcp_tools_enabled"] = bool(c.mcp_tools_enabled)
     if c.mcp_servers is not None:
         out["mcp_servers"] = list(c.mcp_servers)
+    if c.write_tool_enabled is not None:
+        out["write_tool_enabled"] = bool(c.write_tool_enabled)
+    if c.edit_tool_enabled is not None:
+        out["edit_tool_enabled"] = bool(c.edit_tool_enabled)
     return out
 
 

src/amcp/tools.py

@@ -480,8 +480,129 @@ class GrepTool(BaseTool):
         }
 
 
+class WriteFileTool(BaseTool):
+    """Tool for writing content to files."""
+    
+    @property
+    def name(self) -> str:
+        return "write_file"
+    
+    @property
+    def description(self) -> str:
+        return "Write content to a file. Creates new file or overwrites existing file."
+    
+    def execute(self, path: str, content: str) -> ToolResult:
+        """Execute the write file tool."""
+        from pathlib import Path
+        
+        try:
+            file_path = Path(path).expanduser().resolve()
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            file_path.write_text(content, encoding="utf-8")
+            
+            return ToolResult(
+                success=True,
+                content=f"Successfully wrote {len(content)} characters to {file_path}",
+                metadata={"file_path": str(file_path), "size": len(content)}
+            )
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                content="",
+                error=f"Failed to write file: {type(e).__name__}: {e}"
+            )
+    
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Path to the file to write"
+                },
+                "content": {
+                    "type": "string",
+                    "description": "Content to write to the file"
+                }
+            },
+            "required": ["path", "content"],
+            "additionalProperties": False,
+        }
+
+
+class EditFileTool(BaseTool):
+    """Tool for editing files with search and replace."""
+    
+    @property
+    def name(self) -> str:
+        return "edit_file"
+    
+    @property
+    def description(self) -> str:
+        return "Edit a file by replacing old_text with new_text. The old_text must match exactly."
+    
+    def execute(self, path: str, old_text: str, new_text: str) -> ToolResult:
+        """Execute the edit file tool."""
+        from pathlib import Path
+        
+        try:
+            file_path = Path(path).expanduser().resolve()
+            
+            if not file_path.exists():
+                return ToolResult(
+                    success=False,
+                    content="",
+                    error=f"File not found: {file_path}"
+                )
+            
+            content = file_path.read_text(encoding="utf-8")
+            
+            if old_text not in content:
+                return ToolResult(
+                    success=False,
+                    content="",
+                    error="old_text not found in file"
+                )
+            
+            new_content = content.replace(old_text, new_text, 1)
+            file_path.write_text(new_content, encoding="utf-8")
+            
+            return ToolResult(
+                success=True,
+                content=f"Successfully edited {file_path}",
+                metadata={"file_path": str(file_path)}
+            )
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                content="",
+                error=f"Failed to edit file: {type(e).__name__}: {e}"
+            )
+    
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Path to the file to edit"
+                },
+                "old_text": {
+                    "type": "string",
+                    "description": "Text to search for (must match exactly)"
+                },
+                "new_text": {
+                    "type": "string",
+                    "description": "Text to replace with"
+                }
+            },
+            "required": ["path", "old_text", "new_text"],
+            "additionalProperties": False,
+        }
+
+
 # Initialize default tool registry
-def create_default_tool_registry() -> ToolRegistry:
+def create_default_tool_registry(enable_write: bool = True, enable_edit: bool = True) -> ToolRegistry:
     """Create a tool registry with default tools."""
     registry = ToolRegistry()
     
@@ -491,6 +612,11 @@ def create_default_tool_registry() -> ToolRegistry:
     registry.register(ThinkTool())
     registry.register(BashTool())
     
+    if enable_write:
+        registry.register(WriteFileTool())
+    if enable_edit:
+        registry.register(EditFileTool())
+    
     return registry
 
 
@@ -498,11 +624,22 @@ def create_default_tool_registry() -> ToolRegistry:
 _default_registry: Optional[ToolRegistry] = None
 
 
-def get_tool_registry() -> ToolRegistry:
+def get_tool_registry(enable_write: Optional[bool] = None, enable_edit: Optional[bool] = None) -> ToolRegistry:
     """Get the global tool registry instance."""
     global _default_registry
     if _default_registry is None:
-        _default_registry = create_default_tool_registry()
+        # Load config to determine defaults
+        from .config import load_config
+        cfg = load_config()
+        chat_cfg = cfg.chat
+        
+        # Use config values if not explicitly provided
+        if enable_write is None:
+            enable_write = chat_cfg.write_tool_enabled if chat_cfg and chat_cfg.write_tool_enabled is not None else True
+        if enable_edit is None:
+            enable_edit = chat_cfg.edit_tool_enabled if chat_cfg and chat_cfg.edit_tool_enabled is not None else True
+        
+        _default_registry = create_default_tool_registry(enable_write=enable_write, enable_edit=enable_edit)
     return _default_registry