aider-ce 0.88.20__py3-none-any.whl → 0.88.38__py3-none-any.whl

aider/tools/finished.py

@@ -1,48 +1,35 @@
-schema = {
-    "type": "function",
-    "function": {
-        "name": "Finished",
-        "description": (
-            "Declare that we are done with every single sub goal and no further work is needed."
-        ),
-        "parameters": {
-            "type": "object",
-            "properties": {},
-            "required": [],
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "finished"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "Finished",
+            "description": (
+                "Declare that we are done with every single sub goal and no further work is needed."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
         },
-    },
-}
+    }
 
-# Normalized tool name for lookup
-NORM_NAME = "finished"
+    @classmethod
+    def execute(cls, coder):
+        """
+        Mark that the current generation task needs no further effort.
 
+        This gives the LLM explicit control over when it can stop looping
+        """
 
-def _execute_finished(coder):
-    """
-    Mark that the current generation task needs no further effort.
+        if coder:
+            coder.agent_finished = True
+            # coder.io.tool_output("Task Finished!")
+            return "Task Finished!"
 
-    This gives the LLM explicit control over when it can stop looping
-    """
-
-    if coder:
-        coder.agent_finished = True
-        # coder.io.tool_output("Task Finished!")
-        return "Task Finished!"
-
-    # coder.io.tool_Error("Error: Could not mark agent task as finished")
-    return "Error: Could not mark agent task as finished"
-
-
-def process_response(coder, params):
-    """
-    Process the Finished tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters (should be empty for Finished)
-
-    Returns:
-        str: Result message
-    """
-    # Finished tool has no parameters to validate
-    return _execute_finished(coder)
+        # coder.io.tool_Error("Error: Could not mark agent task as finished")
+        return "Error: Could not mark agent task as finished"

aider/tools/git_branch.py

@@ -1,129 +1,127 @@
 from aider.repo import ANY_GIT_ERROR
+from aider.tools.utils.base_tool import BaseTool
 
-schema = {
-    "type": "function",
-    "function": {
-        "name": "GitBranch",
-        "description": (
-            "List branches in the repository with various filtering and formatting options."
-        ),
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "remotes": {
-                    "type": "boolean",
-                    "description": "List remote-tracking branches (-r/--remotes flag)",
-                },
-                "all": {
-                    "type": "boolean",
-                    "description": "List both local and remote branches (-a/--all flag)",
-                },
-                "verbose": {
-                    "type": "boolean",
-                    "description": (
-                        "Show verbose information including commit hash and subject (-v flag)"
-                    ),
-                },
-                "very_verbose": {
-                    "type": "boolean",
-                    "description": (
-                        "Show very verbose information including upstream branch (-vv flag)"
-                    ),
-                },
-                "merged": {
-                    "type": "string",
-                    "description": "Show branches merged into specified commit (--merged flag)",
-                },
-                "no_merged": {
-                    "type": "string",
-                    "description": (
-                        "Show branches not merged into specified commit (--no-merged flag)"
-                    ),
-                },
-                "sort": {
-                    "type": "string",
-                    "description": (
-                        "Sort branches by key (committerdate, authordate, refname, etc.) (--sort"
-                        " flag)"
-                    ),
-                },
-                "format": {
-                    "type": "string",
-                    "description": "Custom output format using placeholders (--format flag)",
-                },
-                "show_current": {
-                    "type": "boolean",
-                    "description": "Show only current branch name (--show-current flag)",
+
+class Tool(BaseTool):
+    NORM_NAME = "gitbranch"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "GitBranch",
+            "description": (
+                "List branches in the repository with various filtering and formatting options."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "remotes": {
+                        "type": "boolean",
+                        "description": "List remote-tracking branches (-r/--remotes flag)",
+                    },
+                    "all": {
+                        "type": "boolean",
+                        "description": "List both local and remote branches (-a/--all flag)",
+                    },
+                    "verbose": {
+                        "type": "boolean",
+                        "description": (
+                            "Show verbose information including commit hash and subject (-v flag)"
+                        ),
+                    },
+                    "very_verbose": {
+                        "type": "boolean",
+                        "description": (
+                            "Show very verbose information including upstream branch (-vv flag)"
+                        ),
+                    },
+                    "merged": {
+                        "type": "string",
+                        "description": "Show branches merged into specified commit (--merged flag)",
+                    },
+                    "no_merged": {
+                        "type": "string",
+                        "description": (
+                            "Show branches not merged into specified commit (--no-merged flag)"
+                        ),
+                    },
+                    "sort": {
+                        "type": "string",
+                        "description": (
+                            "Sort branches by key (committerdate, authordate, refname, etc.)"
+                            " (--sort flag)"
+                        ),
+                    },
+                    "format": {
+                        "type": "string",
+                        "description": "Custom output format using placeholders (--format flag)",
+                    },
+                    "show_current": {
+                        "type": "boolean",
+                        "description": "Show only current branch name (--show-current flag)",
+                    },
                 },
+                "required": [],
             },
-            "required": [],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "gitbranch"
+    }
 
+    @classmethod
+    def execute(
+        cls,
+        coder,
+        remotes=False,
+        all=False,
+        verbose=False,
+        very_verbose=False,
+        merged=None,
+        no_merged=None,
+        sort=None,
+        format=None,
+        show_current=False,
+    ):
+        """
+        List branches in the repository with various filtering and formatting options.
+        """
+        if not coder.repo:
+            return "Not in a git repository."
 
-def _execute_git_branch(coder, params=None):
-    """
-    List branches in the repository with various filtering and formatting options.
-    """
-    if not coder.repo:
-        return "Not in a git repository."
+        try:
+            # Build git command arguments
+            args = []
 
-    try:
-        # Build git command arguments
-        args = []
-
-        # Handle boolean flags
-        if params:
-            if params.get("remotes"):
+            # Handle boolean flags
+            if remotes:
                 args.append("--remotes")
-            if params.get("all"):
+            if all:
                 args.append("--all")
-            if params.get("verbose"):
+            if verbose:
                 args.append("--verbose")
-            if params.get("very_verbose"):
+            if very_verbose:
                 args.append("--verbose")
                 args.append("--verbose")
-            if params.get("show_current"):
+            if show_current:
                 args.append("--show-current")
 
             # Handle string parameters
-            if params.get("merged"):
-                args.extend(["--merged", params["merged"]])
-            if params.get("no_merged"):
-                args.extend(["--no-merged", params["no_merged"]])
-            if params.get("sort"):
-                args.extend(["--sort", params["sort"]])
-            if params.get("format"):
-                args.extend(["--format", params["format"]])
-
-        # Execute git command
-        result = coder.repo.repo.git.branch(*args)
-
-        # If no result and show_current was used, get current branch directly
-        if not result and params and params.get("show_current"):
-            current_branch = coder.repo.repo.active_branch.name
-            return current_branch
-
-        return result if result else "No branches found matching the criteria."
-
-    except ANY_GIT_ERROR as e:
-        coder.io.tool_error(f"Error running git branch: {e}")
-        return f"Error running git branch: {e}"
+            if merged:
+                args.extend(["--merged", merged])
+            if no_merged:
+                args.extend(["--no-merged", no_merged])
+            if sort:
+                args.extend(["--sort", sort])
+            if format:
+                args.extend(["--format", format])
 
+            # Execute git command
+            result = coder.repo.repo.git.branch(*args)
 
-def process_response(coder, params):
-    """
-    Process the GitBranch tool response.
+            # If no result and show_current was used, get current branch directly
+            if not result and show_current:
+                current_branch = coder.repo.repo.active_branch.name
+                return current_branch
 
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters for GitBranch
+            return result if result else "No branches found matching the criteria."
 
-    Returns:
-        str: Result message
-    """
-    return _execute_git_branch(coder, params)
+        except ANY_GIT_ERROR as e:
+            coder.io.tool_error(f"Error running git branch: {e}")
+            return f"Error running git branch: {e}"

aider/tools/git_diff.py

@@ -1,60 +1,48 @@
 from aider.repo import ANY_GIT_ERROR
-
-schema = {
-    "type": "function",
-    "function": {
-        "name": "GitDiff",
-        "description": (
-            "Show the diff between the current working directory and a git branch or commit."
-        ),
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "branch": {
-                    "type": "string",
-                    "description": "The branch or commit hash to diff against. Defaults to HEAD.",
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "gitdiff"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "GitDiff",
+            "description": (
+                "Show the diff between the current working directory and a git branch or commit."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "branch": {
+                        "type": "string",
+                        "description": (
+                            "The branch or commit hash to diff against. Defaults to HEAD."
+                        ),
+                    },
                 },
+                "required": [],
             },
-            "required": [],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "gitdiff"
-
-
-def _execute_git_diff(coder, branch=None):
-    """
-    Show the diff between the current working directory and a git branch or commit.
-    """
-    if not coder.repo:
-        return "Not in a git repository."
-
-    try:
-        if branch:
-            diff = coder.repo.diff_commits(False, branch, "HEAD")
-        else:
-            diff = coder.repo.diff_commits(False, "HEAD", None)
-
-        if not diff:
-            return "No differences found."
-        return diff
-    except ANY_GIT_ERROR as e:
-        coder.io.tool_error(f"Error running git diff: {e}")
-        return f"Error running git diff: {e}"
-
-
-def process_response(coder, params):
-    """
-    Process the GitDiff tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
-
-    Returns:
-        str: Result message
-    """
-    branch = params.get("branch")
-    return _execute_git_diff(coder, branch)
+    }
+
+    @classmethod
+    def execute(cls, coder, branch=None):
+        """
+        Show the diff between the current working directory and a git branch or commit.
+        """
+        if not coder.repo:
+            return "Not in a git repository."
+
+        try:
+            if branch:
+                diff = coder.repo.diff_commits(False, branch, "HEAD")
+            else:
+                diff = coder.repo.diff_commits(False, "HEAD", None)
+
+            if not diff:
+                return "No differences found."
+            return diff
+        except ANY_GIT_ERROR as e:
+            coder.io.tool_error(f"Error running git diff: {e}")
+            return f"Error running git diff: {e}"

aider/tools/git_log.py

@@ -1,57 +1,43 @@
 from aider.repo import ANY_GIT_ERROR
-
-schema = {
-    "type": "function",
-    "function": {
-        "name": "GitLog",
-        "description": "Show the git log.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "limit": {
-                    "type": "integer",
-                    "description": "The maximum number of commits to show. Defaults to 10.",
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "gitlog"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "GitLog",
+            "description": "Show the git log.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "The maximum number of commits to show. Defaults to 10.",
+                    },
                 },
+                "required": [],
             },
-            "required": [],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "gitlog"
-
-
-def _execute_git_log(coder, limit=10):
-    """
-    Show the git log.
-    """
-    if not coder.repo:
-        return "Not in a git repository."
-
-    try:
-        commits = list(coder.repo.repo.iter_commits(max_count=limit))
-        log_output = []
-        for commit in commits:
-            short_hash = commit.hexsha[:8]
-            message = commit.message.strip().split("\n")[0]
-            log_output.append(f"{short_hash} {message}")
-        return "\n".join(log_output)
-    except ANY_GIT_ERROR as e:
-        coder.io.tool_error(f"Error running git log: {e}")
-        return f"Error running git log: {e}"
-
-
-def process_response(coder, params):
-    """
-    Process the GitLog tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
-
-    Returns:
-        str: Result message
-    """
-    limit = params.get("limit", 10)
-    return _execute_git_log(coder, limit)
+    }
+
+    @classmethod
+    def execute(cls, coder, limit=10):
+        """
+        Show the git log.
+        """
+        if not coder.repo:
+            return "Not in a git repository."
+
+        try:
+            commits = list(coder.repo.repo.iter_commits(max_count=limit))
+            log_output = []
+            for commit in commits:
+                short_hash = commit.hexsha[:8]
+                message = commit.message.strip().split("\n")[0]
+                log_output.append(f"{short_hash} {message}")
+            return "\n".join(log_output)
+        except ANY_GIT_ERROR as e:
+            coder.io.tool_error(f"Error running git log: {e}")
+            return f"Error running git log: {e}"

aider/tools/git_remote.py

@@ -1,53 +1,39 @@
 from aider.repo import ANY_GIT_ERROR
-
-schema = {
-    "type": "function",
-    "function": {
-        "name": "GitRemote",
-        "description": "List remote repositories.",
-        "parameters": {
-            "type": "object",
-            "properties": {},
-            "required": [],
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "gitremote"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "GitRemote",
+            "description": "List remote repositories.",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "gitremote"
-
-
-def _execute_git_remote(coder):
-    """
-    List remote repositories.
-    """
-    if not coder.repo:
-        return "Not in a git repository."
-
-    try:
-        remotes = coder.repo.repo.remotes
-        if not remotes:
-            return "No remotes configured."
-
-        result = []
-        for remote in remotes:
-            result.append(f"{remote.name}\t{remote.url}")
-        return "\n".join(result)
-    except ANY_GIT_ERROR as e:
-        coder.io.tool_error(f"Error running git remote: {e}")
-        return f"Error running git remote: {e}"
-
-
-def process_response(coder, params):
-    """
-    Process the GitRemote tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters (should be empty for GitRemote)
-
-    Returns:
-        str: Result message
-    """
-    # GitRemote tool has no parameters to validate
-    return _execute_git_remote(coder)
+    }
+
+    @classmethod
+    def execute(cls, coder):
+        """
+        List remote repositories.
+        """
+        if not coder.repo:
+            return "Not in a git repository."
+
+        try:
+            remotes = coder.repo.repo.remotes
+            if not remotes:
+                return "No remotes configured."
+
+            result = []
+            for remote in remotes:
+                result.append(f"{remote.name}\t{remote.url}")
+            return "\n".join(result)
+        except ANY_GIT_ERROR as e:
+            coder.io.tool_error(f"Error running git remote: {e}")
+            return f"Error running git remote: {e}"