skydeckai-code 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

aidd/tools/file_tools.py

@@ -4,10 +4,12 @@ import os
 import re
 import stat
 import subprocess
+import shutil
 from datetime import datetime
 from typing import List
 
 import mcp.types as types
+from mcp.types import TextContent
 
 from .state import state
 
@@ -15,20 +17,28 @@ from .state import state
 def read_file_tool():
     return {
         "name": "read_file",
-        "description": "Read the complete contents of a file from the file system. "
+        "description": "Read the contents of a file from the file system. "
                     "WHEN TO USE: When you need to examine the actual content of a single file, view source code, check configuration files, or analyze text data. "
                     "This is the primary tool for accessing file contents directly. "
                     "WHEN NOT TO USE: When you only need file metadata like size or modification date (use get_file_info instead), when you need to list directory contents "
                     "(use directory_listing instead), or when you need to read multiple files at once (use read_multiple_files instead). "
-                    "RETURNS: The complete text content of the specified file. Binary files or files with unknown encodings will return an error message. "
+                    "RETURNS: The complete text content of the specified file or the requested portion if offset/limit are specified. Binary files or files with unknown encodings will return an error message. "
                     "Handles various text encodings and provides detailed error messages if the file cannot be read. Only works within the allowed directory. "
-                    "Example: Enter 'src/main.py' to read a Python file.",
+                    "Example: Enter 'src/main.py' to read a Python file, or add offset/limit to read specific line ranges.",
         "inputSchema": {
             "type": "object",
             "properties": {
                 "path": {
                     "type": "string",
-                    "description": "Path to the file to read. This must be a path to a file, not a directory. Examples: 'README.md', 'src/main.py', 'config.json'. Both absolute and relative paths are supported, but must be within the allowed workspace.",
+                    "description": "Path to the file to read. This must be a path to a file, not a directory. Examples: 'README.md', 'src/main.py', 'config.json'. Both absolute and relative paths are supported, but must be within the allowed workspace."
+                },
+                "offset": {
+                    "type": "integer",
+                    "description": "Line number to start reading from (1-indexed). If specified, the file will be read starting from this line. Default is to start from the beginning of the file.",
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Maximum number of lines to read after the offset. If specified along with offset, only this many lines will be read. Default is to read to the end of the file.",
                 }
             },
             "required": ["path"]
@@ -91,6 +101,40 @@ def move_file_tool():
         },
     }
 
+def copy_file_tool():
+    return {
+        "name": "copy_file",
+        "description": "Copy a file or directory to a new location. "
+                    "WHEN TO USE: When you need to duplicate files or directories while keeping the original intact, create backups, "
+                    "or replicate configuration files for different environments. Useful for testing changes without risking original files, "
+                    "creating template files, or duplicating project structures. "
+                    "WHEN NOT TO USE: When you want to move a file without keeping the original (use move_file instead), when the destination "
+                    "already exists (the operation will fail), or when either source or destination is outside the allowed workspace. "
+                    "RETURNS: A confirmation message indicating that the file or directory was successfully copied. "
+                    "For directories, the entire directory structure is copied recursively. Parent directories of the destination "
+                    "will be created automatically if they don't exist. Both source and destination must be within the allowed directory. "
+                    "Example: source='config.json', destination='config.backup.json'",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "source": {
+                    "type": "string",
+                    "description": "Source path of the file or directory to copy. This file or directory must exist. Both absolute and relative paths are supported, but must be within the allowed workspace. Examples: 'document.txt', 'src/utils.js', 'config/settings/'"
+                },
+                "destination": {
+                    "type": "string",
+                    "description": "Destination path where to copy the file or directory. If this path already exists, the operation will fail. Parent directories will be created automatically if they don't exist. Both absolute and relative paths are supported, but must be within the allowed workspace. Examples: 'document.backup.txt', 'backup/document.txt', 'src/new-project/'"
+                },
+                "recursive": {
+                    "type": "boolean",
+                    "description": "Whether to copy directories recursively. If set to true and the source is a directory, all subdirectories and files will be copied. If set to false and the source is a directory, the operation will fail. Defaults to true.",
+                    "default": True
+                }
+            },
+            "required": ["source", "destination"]
+        },
+    }
+
 def search_files_tool():
     return {
         "name": "search_files",
@@ -98,8 +142,8 @@ def search_files_tool():
                     "WHEN TO USE: When you need to find files or directories by name pattern across a directory tree, locate files with specific extensions, "
                     "or find items containing certain text in their names. Useful for locating configuration files, finding all files of a certain type, "
                     "or gathering files related to a specific feature. "
-                    "WHEN NOT TO USE: When searching for content within files (there is no grep tool in this application), when you need a flat listing of a single directory "
-                    "(use directory_listing instead), or when you need to analyze code structure (use codebase_mapper instead). "
+                    "WHEN NOT TO USE: When searching for content within files (use search_code tool for that), when you need a flat listing of a single directory "
+                    "(use list_directory instead), or when you need to analyze code structure (use codebase_mapper instead). "
                     "RETURNS: A list of matching files and directories with their types ([FILE] or [DIR]) and relative paths. "
                     "For Git repositories, only shows tracked files and directories by default. "
                     "The search is recursive and case-insensitive. Only searches within the allowed directory. "
@@ -261,10 +305,8 @@ def edit_file_tool():
         }
     }
 
-async def _read_single_file(path: str) -> List[types.TextContent]:
+async def _read_single_file(path: str, offset: int = None, limit: int = None) -> List[TextContent]:
     """Helper function to read a single file with proper validation."""
-    from mcp.types import TextContent
-
     # Determine full path based on whether input is absolute or relative
     if os.path.isabs(path):
         full_path = os.path.abspath(path)  # Just normalize the absolute path
@@ -282,7 +324,40 @@ async def _read_single_file(path: str) -> List[types.TextContent]:
 
     try:
         with open(full_path, 'r', encoding='utf-8') as f:
-            content = f.read()
+            # If we have offset/limit parameters, read only the specified lines
+            if offset is not None or limit is not None:
+                lines = f.readlines()
+
+                # Determine start line - convert from 1-indexed to 0-indexed
+                start_idx = 0
+                if offset is not None:
+                    start_idx = max(0, offset - 1)  # Convert 1-indexed to 0-indexed
+
+                # Determine end line
+                end_idx = len(lines)
+                if limit is not None:
+                    end_idx = min(len(lines), start_idx + limit)
+
+                # Read only the specified range
+                content = ''.join(lines[start_idx:end_idx])
+
+                # Add summary information about the file before and after the selected range
+                total_lines = len(lines)
+                summary = []
+
+                if start_idx > 0:
+                    summary.append(f"[...{start_idx} lines before...]")
+
+                if end_idx < total_lines:
+                    summary.append(f"[...{total_lines - end_idx} lines after...]")
+
+                if summary:
+                    content = '\n'.join(summary) + '\n' + content
+
+            else:
+                # Read the entire file
+                content = f.read()
+
             return [TextContent(
                 type="text",
                 text=content
@@ -296,8 +371,6 @@ async def _read_single_file(path: str) -> List[types.TextContent]:
 
 async def handle_write_file(arguments: dict):
     """Handle writing content to a file."""
-    from mcp.types import TextContent
-
     path = arguments.get("path")
     content = arguments.get("content")
 
@@ -331,13 +404,16 @@ async def handle_write_file(arguments: dict):
     except Exception as e:
         raise ValueError(f"Error writing file: {str(e)}")
 
-
 async def handle_read_file(arguments: dict):
     path = arguments.get("path")
     if not path:
         raise ValueError("path must be provided")
 
-    return await _read_single_file(path)
+    # Get the line range parameters
+    offset = arguments.get("offset")
+    limit = arguments.get("limit")
+
+    return await _read_single_file(path, offset, limit)
 
 async def handle_read_multiple_files(arguments: dict):
     paths = arguments.get("paths", [])
@@ -348,7 +424,6 @@ async def handle_read_multiple_files(arguments: dict):
     if not paths:
         raise ValueError("paths list cannot be empty")
 
-    from mcp.types import TextContent
     results = []
     for path in paths:
         try:
@@ -369,8 +444,6 @@ async def handle_read_multiple_files(arguments: dict):
 
 async def handle_move_file(arguments: dict):
     """Handle moving a file or directory to a new location."""
-    from mcp.types import TextContent
-
     source = arguments.get("source")
     destination = arguments.get("destination")
 
@@ -415,10 +488,67 @@ async def handle_move_file(arguments: dict):
     except Exception as e:
         raise ValueError(f"Unexpected error: {str(e)}")
 
+async def handle_copy_file(arguments: dict):
+    """Handle copying a file or directory to a new location."""
+    source = arguments.get("source")
+    destination = arguments.get("destination")
+    recursive = arguments.get("recursive", True)
+
+    if not source:
+        raise ValueError("source must be provided")
+    if not destination:
+        raise ValueError("destination must be provided")
+
+    # Determine full paths based on whether inputs are absolute or relative
+    if os.path.isabs(source):
+        full_source = os.path.abspath(source)
+    else:
+        full_source = os.path.abspath(os.path.join(state.allowed_directory, source))
+
+    if os.path.isabs(destination):
+        full_destination = os.path.abspath(destination)
+    else:
+        full_destination = os.path.abspath(os.path.join(state.allowed_directory, destination))
+
+    # Security checks
+    if not full_source.startswith(state.allowed_directory):
+        raise ValueError(f"Access denied: Source path ({full_source}) must be within allowed directory")
+    if not full_destination.startswith(state.allowed_directory):
+        raise ValueError(f"Access denied: Destination path ({full_destination}) must be within allowed directory")
+
+    # Validate source exists
+    if not os.path.exists(full_source):
+        raise ValueError(f"Source path does not exist: {source}")
+
+    # Check if destination already exists
+    if os.path.exists(full_destination):
+        raise ValueError(f"Destination already exists: {destination}")
+
+    # Create parent directories of destination if they don't exist
+    os.makedirs(os.path.dirname(full_destination), exist_ok=True)
+
+    try:
+        if os.path.isdir(full_source):
+            if not recursive:
+                raise ValueError(f"Cannot copy directory without recursive flag: {source}")
+            # Copy directory recursively
+            shutil.copytree(full_source, full_destination)
+            return [TextContent(
+                type="text",
+                text=f"Successfully copied directory {source} to {destination}"
+            )]
+        else:
+            # Copy file
+            shutil.copy2(full_source, full_destination)
+            return [TextContent(
+                type="text",
+                text=f"Successfully copied file {source} to {destination}"
+            )]
+    except Exception as e:
+        raise ValueError(f"Error copying {source} to {destination}: {str(e)}")
+
 async def handle_search_files(arguments: dict):
     """Handle searching for files matching a pattern."""
-    from mcp.types import TextContent
-
     pattern = arguments.get("pattern")
     start_path = arguments.get("path", ".")
     include_hidden = arguments.get("include_hidden", False)
@@ -524,8 +654,6 @@ async def handle_search_files(arguments: dict):
 
 async def handle_get_file_info(arguments: dict):
     """Handle getting detailed information about a file or directory."""
-    from mcp.types import TextContent
-
     path = arguments.get("path")
     if not path:
         raise ValueError("path must be provided")
@@ -566,8 +694,6 @@ Permissions: {perms}"""
 
 async def handle_delete_file(arguments: dict):
     """Handle deleting a file or empty directory."""
-    from mcp.types import TextContent
-
     path = arguments.get("path")
     if not path:
         raise ValueError("path must be provided")
@@ -748,8 +874,6 @@ async def apply_file_edits(file_path: str, edits: List[dict], dry_run: bool = Fa
 
 async def handle_edit_file(arguments: dict):
     """Handle editing a file with pattern matching and formatting."""
-    from mcp.types import TextContent
-
     path = arguments.get("path")
     edits = arguments.get("edits")
     dry_run = arguments.get("dryRun", False)

aidd/tools/git_tools.py

@@ -424,6 +424,46 @@ def git_show_tool():
         }
     }
 
+def git_clone_tool():
+    return {
+        "name": "git_clone",
+        "description": "Clones a remote Git repository into a new directory. "
+                    "WHEN TO USE: When you need to download a copy of an existing Git repository, start working with a "
+                    "remote codebase, or initialize a new local copy of a project. Useful for contributing to open-source "
+                    "projects, setting up new development environments, or accessing shared code repositories. "
+                    "WHEN NOT TO USE: When the target directory already contains a Git repository, when you only need to "
+                    "update an existing repository (use git_pull instead), or when you want to create a new empty repository "
+                    "(use git_init instead). "
+                    "RETURNS: A confirmation message indicating that the repository was successfully cloned, including "
+                    "the source URL and destination directory. Repository must be cloned to a location within the allowed directory.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "URL of the remote repository to clone. This can be an HTTPS URL, SSH URL, or local path. "
+                                   "Examples: 'https://github.com/username/repo.git', 'git@github.com:username/repo.git', "
+                                   "'/path/to/local/repo'. Security restrictions may apply to certain URLs."
+                },
+                "target_path": {
+                    "type": "string",
+                    "description": "Directory where the repository will be cloned. If the directory doesn't exist, it will "
+                                   "be created. If it exists, it must be empty. Examples: 'my-project', 'src/external', "
+                                   "'path/to/clone'. Both absolute and relative paths are supported, but must be within "
+                                   "the allowed workspace."
+                },
+                "branch": {
+                    "type": "string",
+                    "description": "Branch to check out after cloning. If not specified, the repository's default branch "
+                                   "is used. Examples: 'main', 'develop', 'feature/new-feature'. Specifying a branch can "
+                                   "save time when working with large repositories.",
+                    "default": None
+                }
+            },
+            "required": ["url", "target_path"]
+        }
+    }
+
 async def handle_git_status(arguments: dict) -> List[TextContent]:
     """Handle getting git repository status."""
     repo = _get_repo(arguments["repo_path"])
@@ -685,3 +725,50 @@ async def handle_git_show(arguments: dict) -> List[TextContent]:
         )]
     except Exception as e:
         raise ValueError(f"Error showing commit at '{repo.working_dir}': {str(e)}")
+
+async def handle_git_clone(arguments: dict) -> List[TextContent]:
+    """Handle cloning a remote git repository."""
+    url = arguments.get("url")
+    if not url:
+        raise ValueError("url is required")
+    target_path = arguments.get("target_path")
+    if not target_path:
+        raise ValueError("target_path is required")
+    branch = arguments.get("branch")
+
+    # Determine full path based on whether input is absolute or relative
+    if os.path.isabs(target_path):
+        full_path = os.path.abspath(target_path)
+    else:
+        full_path = os.path.abspath(os.path.join(state.allowed_directory, target_path))
+
+    # Security check
+    if not full_path.startswith(state.allowed_directory):
+        raise ValueError(f"Access denied: Path ({full_path}) must be within allowed directory")
+
+    try:
+        # Check if directory exists and is empty
+        if os.path.exists(full_path):
+            if os.path.isdir(full_path) and os.listdir(full_path):
+                raise ValueError(f"Target directory '{full_path}' is not empty")
+            elif not os.path.isdir(full_path):
+                raise ValueError(f"Target path '{full_path}' exists but is not a directory")
+        else:
+            # Create directory if it doesn't exist
+            os.makedirs(full_path, exist_ok=True)
+
+        # Clone options
+        clone_args = {}
+        if branch:
+            clone_args["branch"] = branch
+
+        # Perform the clone
+        repo = git.Repo.clone_from(url, full_path, **clone_args)
+
+        branch_info = f" (branch: {branch})" if branch else ""
+        return [TextContent(
+            type="text",
+            text=f"Repository successfully cloned from {url} to {target_path}{branch_info}"
+        )]
+    except Exception as e:
+        raise ValueError(f"Error cloning repository: {str(e)}")

aidd/tools/other_tools.py

@@ -0,0 +1,238 @@
+import asyncio
+from typing import List, Dict, Any, Callable
+
+from mcp.types import TextContent
+
+from .state import state
+
+
+def batch_tools_tool():
+    return {
+        "name": "batch_tools",
+        "description": "Execute multiple tool invocations in parallel or serially. "
+                    "WHEN TO USE: When you need to run multiple operations efficiently in a single request, "
+                    "combine related operations, or gather results from different tools. Useful for bulk operations, "
+                    "coordinated tasks, or performing multiple queries simultaneously. "
+                    "WHEN NOT TO USE: When operations need to be performed strictly in sequence where each step depends "
+                    "on the previous step's result, when performing simple operations that don't benefit from batching, "
+                    "or when you need fine-grained error handling. "
+                    "RETURNS: Results from all tool invocations grouped together. Each result includes the tool name "
+                    "and its output. If any individual tool fails, its error is included but other tools continue execution. "
+                    "Parallelizable tools are executed concurrently for performance. Each tool's output is presented in "
+                    "a structured format along with the description you provided. "
+                    "IMPORTANT NOTE: All tools in the batch execute in the same working directory context. If a tool creates a directory "
+                    "and a subsequent tool needs to work inside that directory, you must either use paths relative to the current working directory "
+                    "or include an explicit tool invocation to change directories (e.g., update_allowed_directory).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "description": {
+                    "type": "string",
+                    "description": "A short (3-5 word) description of the batch operation. This helps identify the purpose "
+                                   "of the batch and provides context for the results. Examples: 'Setup new project', "
+                                   "'Analyze codebase', 'Gather system info'."
+                },
+                "sequential": {
+                    "type": "boolean",
+                    "description": "Whether to run tools in sequential order (true) or parallel when possible (false). "
+                                  "Use sequential mode when tools need to build on the results of previous tools. "
+                                  "Default is false (parallel execution).",
+                    "default": False
+                },
+                "invocations": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "tool": {
+                                "type": "string",
+                                "description": "Name of the tool to invoke. Must be a valid tool name registered in the system."
+                            },
+                            "arguments": {
+                                "type": "object",
+                                "description": "Arguments to pass to the tool. These should match the required arguments "
+                                               "for the specified tool."
+                            }
+                        },
+                        "required": ["tool", "arguments"]
+                    },
+                    "description": "List of tool invocations to execute. Each invocation specifies a tool name and its arguments. "
+                                  "These will be executed in parallel when possible, or serially when necessary."
+                }
+            },
+            "required": ["description", "invocations"]
+        }
+    }
+
+
+async def handle_batch_tools(arguments: dict) -> List[TextContent]:
+    """Handle executing multiple tools in batch."""
+    # Import TOOL_HANDLERS here to avoid circular imports
+    from . import TOOL_HANDLERS
+
+    description = arguments.get("description")
+    invocations = arguments.get("invocations", [])
+    sequential = arguments.get("sequential", False)
+
+    if not description:
+        raise ValueError("Description must be provided")
+    if not invocations:
+        raise ValueError("Invocations list must not be empty")
+
+    # Validate that all tools exist before running any
+    for idx, invocation in enumerate(invocations):
+        tool_name = invocation.get("tool")
+        if not tool_name:
+            raise ValueError(f"Tool name missing in invocation #{idx+1}")
+
+        if tool_name not in TOOL_HANDLERS:
+            raise ValueError(f"Unknown tool '{tool_name}' in invocation #{idx+1}")
+
+    # Format the results header
+    header = f"Batch Operation: {description}\n"
+    execution_mode = "Sequential" if sequential else "Parallel"
+    header += f"Execution Mode: {execution_mode}\n"
+
+    # Combine all results
+    all_contents = [TextContent(type="text", text=header)]
+
+    if sequential:
+        # Sequential execution
+        for idx, invocation in enumerate(invocations):
+            tool_name = invocation.get("tool")
+            tool_args = invocation.get("arguments", {})
+
+            # Get the handler for this tool
+            handler = TOOL_HANDLERS[tool_name]
+
+            # Execute the tool and process results
+            result = await _execute_tool_with_error_handling(handler, tool_args, tool_name, idx)
+
+            # Add the result to our output
+            status = "SUCCESS" if result["success"] else "ERROR"
+            section_header = f"[{idx+1}] {tool_name} - {status}\n"
+            all_contents.append(TextContent(type="text", text=f"\n{section_header}{'=' * len(section_header)}\n"))
+
+            if result["success"]:
+                all_contents.extend(result["content"])
+            else:
+                all_contents.append(TextContent(
+                    type="text",
+                    text=f"Error: {result['error']}"
+                ))
+
+                # If a tool fails in sequential mode, we stop execution
+                if idx < len(invocations) - 1:
+                    all_contents.append(TextContent(
+                        type="text",
+                        text=f"\nExecution stopped after failure. Remaining {len(invocations) - idx - 1} tools were not executed."
+                    ))
+                break
+    else:
+        # Parallel execution
+        tasks = []
+
+        for idx, invocation in enumerate(invocations):
+            tool_name = invocation.get("tool")
+            tool_args = invocation.get("arguments", {})
+
+            # Create a task for each invocation
+            handler = TOOL_HANDLERS[tool_name]
+            task = asyncio.create_task(
+                _execute_tool_with_error_handling(handler, tool_args, tool_name, idx)
+            )
+            tasks.append(task)
+
+        # Wait for all tasks to complete
+        completed_results = await asyncio.gather(*tasks)
+
+        # Process results
+        for tool_result in completed_results:
+            tool_name = tool_result["tool_name"]
+            idx = tool_result["index"]
+            status = "SUCCESS" if tool_result["success"] else "ERROR"
+
+            # Add separator and header for this tool's results
+            section_header = f"[{idx+1}] {tool_name} - {status}\n"
+            all_contents.append(TextContent(type="text", text=f"\n{section_header}{'=' * len(section_header)}\n"))
+
+            # Add the actual content from the tool
+            if tool_result["success"]:
+                all_contents.extend(tool_result["content"])
+            else:
+                all_contents.append(TextContent(
+                    type="text",
+                    text=f"Error: {tool_result['error']}"
+                ))
+
+    return all_contents
+
+
+async def _execute_tool_with_error_handling(handler, arguments, tool_name, index):
+    """Execute a single tool with error handling."""
+    try:
+        content = await handler(arguments)
+        return {
+            "tool_name": tool_name,
+            "index": index,
+            "success": True,
+            "content": content
+        }
+    except Exception as e:
+        return {
+            "tool_name": tool_name,
+            "index": index,
+            "success": False,
+            "error": str(e)
+        }
+
+
+def think_tool():
+    return {
+        "name": "think",
+        "description": "Use the tool to think about something. "
+                    "WHEN TO USE: When complex reasoning or brainstorming is needed without making any changes to files "
+                    "or retrieving additional information. Useful for analyzing problems, planning approaches, evaluating "
+                    "options, or organizing thoughts before taking action. "
+                    "WHEN NOT TO USE: When immediate action is needed, when you need to query for new information, "
+                    "or when a simple explanation would suffice. "
+                    "RETURNS: The thoughts you provided, formatted as markdown. This tool does not retrieve new information "
+                    "or make any changes to the repository - it simply records your reasoning process for reference. "
+                    "This is particularly valuable when exploring complex bugs, designing architecture, or evaluating "
+                    "multiple approaches to a problem.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "thought": {
+                    "type": "string",
+                    "description": "Your detailed thoughts, analysis, reasoning, or brainstorming. Can include markdown "
+                                   "formatting for better readability, like bullet points, headings, or code blocks. "
+                                   "Examples: Analyzing the root cause of a bug, evaluating different API design choices, "
+                                   "planning refactoring steps, or brainstorming optimization strategies."
+                }
+            },
+            "required": ["thought"]
+        }
+    }
+
+
+async def handle_think(arguments: dict) -> List[TextContent]:
+    """Handle recording a thought without making any changes."""
+    thought = arguments.get("thought")
+
+    if not thought:
+        raise ValueError("Thought must be provided")
+
+    # Format the thought in markdown
+    formatted_thought = f"""# Thought Process
+
+{thought}
+
+---
+*Note: This is a thinking tool used for reasoning and brainstorming. No changes were made to the repository.*
+"""
+
+    return [TextContent(
+        type="text",
+        text=formatted_thought
+    )]