Upload 2 files

app.py

@@ -11,7 +11,7 @@ from smolagents.agent_types import AgentAudio, AgentImage, AgentText
 from smolagents.memory import ActionStep, FinalAnswerStep, MemoryStep
 from smolagents.models import ChatMessageStreamDelta
 from smolagents.utils import _is_package_available
-from tools import search, scraper, FileReader, FileWriter, CommitChanges, get_repository_structure # Assuming tools.py is in the same directory
+from tools import search, scraper, FileReader, FileWriter, CommitChanges, get_repository_structure, FileCopier, FileMover, FileDeleter, FileSearcher
 
 def get_step_footnote_content(step_log: MemoryStep, step_name: str) -> str:
     """Get a footnote string for a step log with duration and token information"""
@@ -305,13 +305,17 @@ class GradioUI:
         read_file = FileReader(space_id=space_id, folder_path=temp_dir)
         write_file = FileWriter(space_id=space_id, folder_path=temp_dir)
         commit_changes = CommitChanges(space_id=space_id, folder_path=temp_dir)
+        file_copier = FileCopier(space_id=space_id, folder_path=temp_dir)
+        file_mover = FileMover(space_id=space_id, folder_path=temp_dir)
+        file_deleter = FileDeleter(space_id=space_id, folder_path=temp_dir)
+        file_searcher = FileSearcher(space_id=space_id, folder_path=temp_dir)
 
         # Initialize SWE Agent with enhanced capabilities and improved description
         swe_agent = CodeAgent(
             model=model,
             prompt_templates=swe_agent_prompt_templates,
             verbosity_level=1,
-            tools=[search, scraper, read_file, write_file],
+            tools=[search, scraper, read_file, write_file, file_copier, file_mover, file_deleter, file_searcher],
             name="swe_agent",
             description="An expert Software Engineer capable of designing, developing, and debugging code. This agent can read and write files, search the web, and scrape web content to assist in coding tasks. It excels at implementing detailed technical specifications provided by the Planning Agent."
         )
@@ -456,7 +460,7 @@ class GradioUI:
         )
 
     def launch(self, share: bool = True, **kwargs):
-        self.create_app().launch(debug=True, share=share, **kwargs)
+        self.create_app().launch(debug=True, share=share, create_mcp_server=True, **kwargs)
 
     def create_app(self):
         import gradio as gr
@@ -556,8 +560,8 @@ def run_gradio_agent():
     """Runs the Gradio UI for the agent."""
     # The GradioUI class now handles space_id input and agent initialization internally
     GradioUI(
-        agent_name="SmolAgents Gradio Interface",
-        agent_description="Interact with a SmolAgents planning agent capable of code generation and execution."
+        agent_name="SmolSWE Gradio Interface",
+        agent_description="Interact with a SmolSWE an AI assistant for software development. Currently in beta. It can do tasks like refactoring, debugging, adding any features, and more."
     ).launch()
 
 if __name__ == "__main__":

tools.py

@@ -1,154 +1,316 @@
-from googlesearch import search as google_search
-from smolagents import tool, Tool
-from curl_scraper import BasicScraper
-from huggingface_hub import hf_hub_download, upload_folder
-import os
-
-class FileReader(Tool):
-    name = "read_file"
-    description = "Reads a file and returns the contents as a string."
-    inputs = {"file": {"type": "string", "description": "The absolute path to the file to be read."}}
-    output_type = "string"
-
-    def __init__(self, space_id, folder_path, **kwargs):
-        super().__init__()
-        self.space_id = space_id
-        self.folder_path = folder_path
-
-    def forward(self, file: str) -> str:
-        file_path = os.path.join(self.folder_path, file)
-        if not os.path.exists(file_path):
-            hf_hub_download(repo_id=self.space_id, filename=file, repo_type="space", local_dir=self.folder_path, local_dir_use_symlinks=False)
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-
-        return content
-
-class FileWriter(Tool):
-    name = "write_file"
-    description = "Overwrite or append content to a file. Use for creating new files, appending content, or modifying existing files."
-    inputs = {
-        "file": {"type": "string", "description": "The absolute path to the file to be written."},
-        "content": {"type": "string", "description": "The content to be written to the file."},
-        "append": {"type": "boolean", "description": "Whether to append to the file or overwrite it.", "nullable": True},
-    }
-    output_type = "string"
-
-    def __init__(self, space_id, folder_path, **kwargs):
-        super().__init__()
-        self.space_id = space_id
-        self.folder_path = folder_path
-
-    def forward(self, file: str, content: str, append: bool = False) -> str:
-        file_path = os.path.join(self.folder_path, file)
-        mode = 'a' if append else 'w'
-        with open(file_path, mode, encoding='utf-8') as f:
-            f.write(content if append else content.strip())
-        return f"Successfully {'appended to' if append else 'wrote to'} file at {file_path}"
-
-@tool
-def search(query: str) -> list:
-    """
-    Search for web pages and scrape their content.
-
-    Args:
-        query (str): The search query.
-    
-    Returns:
-        list: List of top web results including url, title, description from the search results.
-    """
-    # Get search results
-    results = []
-    for result in google_search(query, advanced=True, unique=True):
-        results.append(result)
-    return results
-
-@tool
-def scraper(url: str, response_type: str = 'plain_text') -> str:
-    """
-    Scrapes the content of a web page. Important: Don't use regex to extract information from the output of a this scraper tool, Think more and find answer yourself.
-
-    Args:
-        url (str): The URL of the web page to scrape.
-        response_type (str): The type of response to return. Valid options are 'markdown' and 'plain_text'. Default is 'plain_text'.
-
-    Returns:
-        str: The content of the web page in the specified format.
-    """
-    response = BasicScraper(timeout=5).get(url)
-    if response_type == 'markdown':
-        return response.markdown
-    elif response_type == 'plain_text':
-        return response.plain_text
-    else:
-        raise ValueError("Invalid response_type. Use 'markdown' or 'plain_text'.")
-
-class CommitChanges(Tool):
-    name = "commit_changes"
-    description = "Commits changes to a repository."
-    inputs = {
-        "commit_message": {"type": "string", "description": "The commit message."},
-        "commit_description": {"type": "string", "description": "The commit description."},
-    }
-    output_type = "string"
-
-    def __init__(self, space_id, folder_path, **kwargs):
-        super().__init__()
-        self.space_id = space_id
-        self.folder_path = folder_path
-
-    def forward(self, commit_message: str, commit_description: str) -> str:
-        try:
-            upload_folder(
-                folder_path=self.folder_path,
-                repo_id=self.space_id,
-                repo_type="space",
-                create_pr=True,
-                commit_message=commit_message,
-                commit_description=commit_description,
-            )
-            return "Changes committed successfully."
-        except Exception as e:
-            return f"Error committing changes: {str(e)}"
-
-from huggingface_hub import HfApi
-
-def get_repository_structure(space_id: str) -> str:
-    api = HfApi()
-    space_info = api.space_info(space_id)
-    
-    printed_dirs = set()
-    output_lines = []
-    sorted_siblings = sorted(space_info.siblings, key=lambda x: x.rfilename)
-    
-    for sibling in sorted_siblings:
-        rfilename = sibling.rfilename
-        path_parts = rfilename.split('/')
-        
-        current_dir_path_parts = []
-        for i in range(len(path_parts) - 1):
-            dir_name = path_parts[i]
-            current_dir_path_parts.append(dir_name)
-            dir_path = '/'.join(current_dir_path_parts)
-
-            if dir_path not in printed_dirs:
-                depth = i
-                indent = '  ' * depth
-                output_lines.append(f"{indent}{dir_name}")
-                printed_dirs.add(dir_path)
-
-        file_name = path_parts[-1]
-        file_indent_depth = len(path_parts) - 1
-        file_indent = '  ' * file_indent_depth
-
-        if file_indent_depth == 0:
-            output_lines.append(file_name)
-        else:
-            is_last_file = sibling == sorted_siblings[-1] or not any(
-                s.rfilename.startswith('/'.join(path_parts[:-1]) + '/') 
-                for s in sorted_siblings[sorted_siblings.index(sibling)+1:]
-            )
-            file_prefix = '└─ ' if is_last_file else '├─ '
-            output_lines.append(f"{file_indent}{file_prefix}{file_name}")
-    
+from googlesearch import search as google_search
+from smolagents import tool, Tool
+from curl_scraper import BasicScraper
+from huggingface_hub import hf_hub_download, upload_folder
+import os
+
+class FileReader(Tool):
+    name = "read_file"
+    description = "Reads a file and returns the contents as a string."
+    inputs = {"file": {"type": "string", "description": "The absolute path to the file to be read."}}
+    output_type = "string"
+
+    def __init__(self, space_id, folder_path, **kwargs):
+        super().__init__()
+        self.space_id = space_id
+        self.folder_path = folder_path
+
+    def forward(self, file: str) -> str:
+        file_path = os.path.join(self.folder_path, file)
+        if not os.path.exists(file_path):
+            hf_hub_download(repo_id=self.space_id, filename=file, repo_type="space", local_dir=self.folder_path, local_dir_use_symlinks=False)
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        return content
+
+class FileWriter(Tool):
+    name = "write_file"
+    description = "Overwrite or append content to a file. Use for creating new files, appending content, or modifying existing files."
+    inputs = {
+        "file": {"type": "string", "description": "The absolute path to the file to be written."},
+        "content": {"type": "string", "description": "The content to be written to the file."},
+        "append": {"type": "boolean", "description": "Whether to append to the file or overwrite it.", "nullable": True},
+    }
+    output_type = "string"
+
+    def __init__(self, space_id, folder_path, **kwargs):
+        super().__init__()
+        self.space_id = space_id
+        self.folder_path = folder_path
+
+    def forward(self, file: str, content: str, append: bool = False) -> str:
+        file_path = os.path.join(self.folder_path, file)
+        mode = 'a' if append else 'w'
+        with open(file_path, mode, encoding='utf-8') as f:
+            f.write(content if append else content.strip())
+        return f"Successfully {'appended to' if append else 'wrote to'} file at {file_path}"
+
+@tool
+def search(query: str) -> list:
+    """
+    Search for web pages and scrape their content.
+
+    Args:
+        query (str): The search query.
+    
+    Returns:
+        list: List of top web results including url, title, description from the search results.
+    """
+    # Get search results
+    results = []
+    for result in google_search(query, advanced=True, unique=True):
+        results.append(result)
+    return results
+
+@tool
+def scraper(url: str, response_type: str = 'plain_text') -> str:
+    """
+    Scrapes the content of a web page. Important: Don't use regex to extract information from the output of a this scraper tool, Think more and find answer yourself.
+
+    Args:
+        url (str): The URL of the web page to scrape.
+        response_type (str): The type of response to return. Valid options are 'markdown' and 'plain_text'. Default is 'plain_text'.
+
+    Returns:
+        str: The content of the web page in the specified format.
+    """
+    response = BasicScraper(timeout=5).get(url)
+    if response_type == 'markdown':
+        return response.markdown
+    elif response_type == 'plain_text':
+        return response.plain_text
+    else:
+        raise ValueError("Invalid response_type. Use 'markdown' or 'plain_text'.")
+
+class CommitChanges(Tool):
+    name = "commit_changes"
+    description = "Commits changes to a repository."
+    inputs = {
+        "commit_message": {"type": "string", "description": "The commit message."},
+        "commit_description": {"type": "string", "description": "The commit description."},
+    }
+    output_type = "string"
+
+    def __init__(self, space_id, folder_path, **kwargs):
+        super().__init__()
+        self.space_id = space_id
+        self.folder_path = folder_path
+
+    def forward(self, commit_message: str, commit_description: str) -> str:
+        try:
+            upload_folder(
+                folder_path=self.folder_path,
+                repo_id=self.space_id,
+                repo_type="space",
+                create_pr=True,
+                commit_message=commit_message,
+                commit_description=commit_description,
+            )
+            return "Changes committed successfully."
+        except Exception as e:
+            return f"Error committing changes: {str(e)}"
+
+from huggingface_hub import HfApi
+import shutil
+import os
+import fnmatch
+from typing import List, Dict, Any, Optional, Union
+from pathlib import Path
+
+
+class FileMover(Tool):
+    name = "move_file"
+    description = "Move or rename a file or directory."
+    inputs = {
+        "source": {"type": "string", "description": "Source file or directory path"},
+        "destination": {"type": "string", "description": "Destination path"}
+    }
+    output_type = "string"
+
+    def __init__(self, space_id, folder_path, **kwargs):
+        super().__init__()
+        self.space_id = space_id
+        self.folder_path = folder_path
+
+    def forward(self, source: str, destination: str) -> str:
+        src_path = os.path.join(self.folder_path, source)
+        dst_path = os.path.join(self.folder_path, destination)
+        
+        if not os.path.exists(src_path):
+            return f"Error: Source path does not exist: {src_path}"
+            
+        try:
+            shutil.move(src_path, dst_path)
+            return f"Successfully moved {src_path} to {dst_path}"
+        except Exception as e:
+            return f"Error moving {src_path}: {str(e)}"
+
+
+class FileCopier(Tool):
+    name = "copy_file"
+    description = "Copy a file or directory."
+    inputs = {
+        "source": {"type": "string", "description": "Source file or directory path"},
+        "destination": {"type": "string", "description": "Destination path"}
+    }
+    output_type = "string"
+
+    def __init__(self, space_id, folder_path, **kwargs):
+        super().__init__()
+        self.space_id = space_id
+        self.folder_path = folder_path
+
+    def forward(self, source: str, destination: str) -> str:
+        src_path = os.path.join(self.folder_path, source)
+        dst_path = os.path.join(self.folder_path, destination)
+        
+        if not os.path.exists(src_path):
+            return f"Error: Source path does not exist: {src_path}"
+            
+        try:
+            if os.path.isdir(src_path):
+                shutil.copytree(src_path, dst_path)
+            else:
+                shutil.copy2(src_path, dst_path)
+            return f"Successfully copied {src_path} to {dst_path}"
+        except Exception as e:
+            return f"Error copying {src_path}: {str(e)}"
+
+
+class FileDeleter(Tool):
+    name = "delete_file"
+    description = "Delete a file or directory."
+    inputs = {
+        "path": {"type": "string", "description": "Path to file or directory to delete"}
+    }
+    output_type = "string"
+
+    def __init__(self, space_id, folder_path, **kwargs):
+        super().__init__()
+        self.space_id = space_id
+        self.folder_path = folder_path
+
+    def forward(self, path: str) -> str:
+        full_path = os.path.join(self.folder_path, path)
+        
+        if not os.path.exists(full_path):
+            return f"Error: Path does not exist: {full_path}"
+            
+        try:
+            if os.path.isdir(full_path):
+                shutil.rmtree(full_path)
+            else:
+                os.remove(full_path)
+            return f"Successfully deleted: {full_path}"
+        except Exception as e:
+            return f"Error deleting {full_path}: {str(e)}"
+
+
+class FileSearcher(Tool):
+    name = "search_files"
+    description = "Search for text within files in the repository."
+    inputs = {
+        "search_term": {"type": "string", "description": "Text to search for"},
+        "file_pattern": {"type": "string", "description": "File pattern to search in (e.g., '*.txt' for all .txt files)", "default": "*"},
+        "case_sensitive": {"type": "boolean", "description": "Whether the search should be case sensitive", "default": False}
+    }
+    output_type = "list"
+
+    def __init__(self, space_id, folder_path, **kwargs):
+        super().__init__()
+        self.space_id = space_id
+        self.folder_path = folder_path
+
+    def _find_files(self, pattern: str) -> List[str]:
+        """Find all files matching the pattern in the repository."""
+        matches = []
+        for root, _, filenames in os.walk(self.folder_path):
+            for filename in fnmatch.filter(filenames, pattern):
+                matches.append(os.path.join(root, filename))
+        return matches
+
+    def _search_in_file(self, file_path: str, search_term: str, case_sensitive: bool) -> List[Dict[str, Any]]:
+        """Search for the term in a single file."""
+        matches = []
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                for line_num, line in enumerate(f, 1):
+                    if not case_sensitive:
+                        if search_term.lower() in line.lower():
+                            matches.append({
+                                'file': os.path.relpath(file_path, self.folder_path),
+                                'line': line_num,
+                                'content': line.strip()
+                            })
+                    else:
+                        if search_term in line:
+                            matches.append({
+                                'file': os.path.relpath(file_path, self.folder_path),
+                                'line': line_num,
+                                'content': line.strip()
+                            })
+        except Exception as e:
+            return [{'file': file_path, 'error': f"Error reading file: {str(e)}"}]
+        return matches
+
+    def forward(self, search_term: str, file_pattern: str = "*", case_sensitive: bool = False) -> List[Dict[str, Any]]:
+        if not search_term.strip():
+            return [{"error": "Search term cannot be empty"}]
+            
+        try:
+            matching_files = self._find_files(file_pattern)
+            if not matching_files:
+                return [{"message": f"No files found matching pattern: {file_pattern}"}]
+                
+            results = []
+            for file_path in matching_files:
+                file_matches = self._search_in_file(file_path, search_term, case_sensitive)
+                if file_matches:
+                    results.extend(file_matches)
+                    
+            return results if results else [{"message": "No matches found"}]
+            
+        except Exception as e:
+            return [{"error": f"Error during search: {str(e)}"}]
+
+
+def get_repository_structure(space_id: str) -> str:
+    api = HfApi()
+    space_info = api.space_info(space_id)
+    
+    printed_dirs = set()
+    output_lines = []
+    sorted_siblings = sorted(space_info.siblings, key=lambda x: x.rfilename)
+    
+    for sibling in sorted_siblings:
+        rfilename = sibling.rfilename
+        path_parts = rfilename.split('/')
+        
+        current_dir_path_parts = []
+        for i in range(len(path_parts) - 1):
+            dir_name = path_parts[i]
+            current_dir_path_parts.append(dir_name)
+            dir_path = '/'.join(current_dir_path_parts)
+
+            if dir_path not in printed_dirs:
+                depth = i
+                indent = '  ' * depth
+                output_lines.append(f"{indent}{dir_name}")
+                printed_dirs.add(dir_path)
+
+        file_name = path_parts[-1]
+        file_indent_depth = len(path_parts) - 1
+        file_indent = '  ' * file_indent_depth
+
+        if file_indent_depth == 0:
+            output_lines.append(file_name)
+        else:
+            is_last_file = sibling == sorted_siblings[-1] or not any(
+                s.rfilename.startswith('/'.join(path_parts[:-1]) + '/') 
+                for s in sorted_siblings[sorted_siblings.index(sibling)+1:]
+            )
+            file_prefix = '└─ ' if is_last_file else '├─ '
+            output_lines.append(f"{file_indent}{file_prefix}{file_name}")
+    
     return '\n'.join(output_lines)