update

Author: CTY-git

patchwork/steps/ResolveIssue/ResolveIssue.py

@@ -1,6 +1,6 @@
 import re
 from pathlib import Path
-from typing import Any
+from typing import Any, Optional
 
 from git import Repo
 from openai.types.chat import ChatCompletionMessageParam
@@ -20,7 +20,7 @@
 
 class _ResolveIssue(AnalyzeImplementStrategy):
     def __init__(self, repo_path: str, llm_client: LlmClient, issue_description: Any, **kwargs):
-        self.tool_set = Tool.get_tools(repo_path=repo_path)
+        self.tool_set = Tool.get_tools(path=repo_path)
         super().__init__(
             llm_client=llm_client,
             initial_template_data=dict(issue=issue_description),
@@ -74,10 +74,10 @@ def __init__(self, repo_path: str, llm_client: LlmClient, issue_description: Any
             **kwargs,
         )
 
-    def extract_analysis_message(self, message: ChatCompletionMessageParam) -> dict[str, str]:
+    def extract_analysis_message(self, message: ChatCompletionMessageParam) -> Optional[dict[str, str]]:
         analysis_match = re.search(r"<analysis>(.*?)</analysis>", message.get("content"), re.DOTALL)
         if not analysis_match:
-            return dict()
+            return None
 
         content = analysis_match.group(1)
         sections = dict()
@@ -112,12 +112,11 @@ def __init__(self, inputs):
                 "\n"
                 "If you are using an OpenAI API Key, please set `--openai_api_key=<token>`.\n"
             )
-        issue_description = inputs.get("issue_description")
 
         self.multiturn_llm_call = _ResolveIssue(
             repo_path=self.base_path,
             llm_client=llm_client,
-            issue_description=issue_description,
+            issue_description=inputs["issue_description"],
         )
 
     def run(self):

patchwork/steps/ResolveIssue/multiturn_strategy/analyze_implement.py

@@ -31,7 +31,7 @@ def __init__(
         implementation_prompt_template: str,
         **kwargs,
     ):
-        super().__init__(tool_set, **kwargs)
+        super().__init__(tool_set=tool_set, **kwargs)
         self.llm_client = llm_client
         self.template_data = initial_template_data
         self.analysis_prompt_template = analysis_prompt_template
@@ -54,7 +54,8 @@ def __run_prompt(self, messages: list[ChatCompletionMessageParam]) -> list[ChatC
         if is_prompt_safe < 0:
             raise ValueError("The subsequent prompt is not supported, due to large size.")
         response = self.llm_client.chat_completion(**input_kwargs)
-        messages.append(response.choices[0].message.to_dict())
+        new_messages = [choice.message.to_dict() for choice in response.choices]
+        messages.extend(new_messages)
         return messages
 
     def __render_prompt(self, prompt: str) -> str:
@@ -81,12 +82,12 @@ def run_subsequent_prompt(self, messages: list[ChatCompletionMessageParam]) -> l
                 self.template_data["analysis_results"] = possible_analysis_message
                 implement_prompt = self.__render_prompt(self.implementation_prompt_template)
                 messages = [dict(role="user", content=implement_prompt)]
-        else:
-            if last_message.get("tool_calls") is not None:
-                tool_messages = self.execute_tools(last_message)
-                messages.extend(tool_messages)
-            messages.append(dict(role="user", content=f"Continue with the {self._stage.name.lower()} stage."))
+                return self.__run_prompt(messages)
 
+        if last_message.get("tool_calls") is not None:
+            tool_messages = self.execute_tools(last_message)
+            messages.extend(tool_messages)
+        messages.append(dict(role="user", content=f"Continue with the {self._stage.name.upper()} stage."))
         return self.__run_prompt(messages)
 
     @abstractmethod

patchwork/steps/ResolveIssue/multiturn_strategy/multiturn_strategy.py

@@ -25,38 +25,40 @@ def get_tools_spec(self) -> list[ChatCompletionToolParam]:
         return [
             dict(
                 type="function",
-                function=dict(name=k, **v.json_schema),
+                function={"name": k, **v.json_schema},
             )
             for k, v in self.tool_set.items()
         ]
 
     @abstractmethod
-    def run_initial_prompt(self) -> list[ChatCompletionMessageParam]:
+    def run_initial_prompt(self) -> tuple[ChatCompletionMessage, list[ChatCompletionMessageParam]]:
         pass
 
     @abstractmethod
-    def run_subsequent_prompt(self, messages: list[ChatCompletionMessageParam]) -> ChatCompletionMessage:
+    def run_subsequent_prompt(self, messages: list[ChatCompletionMessageParam]) -> list[ChatCompletionMessageParam]:
         pass
 
     def is_stop(self, messages: list[ChatCompletionMessageParam]) -> bool:
         return False
 
-    def execute_tools(self, chat_completion_message: ChatCompletionMessageParam) -> list[ChatCompletionMessageParam]:
+    def execute_tools(self, last_message: ChatCompletionMessageParam) -> list[ChatCompletionMessageParam]:
         rv = []
-        for tool_call in chat_completion_message.tool_calls:
-            tooling_to_use = self.tooling.get(tool_call.function.name, None)
-            if tooling_to_use is None:
+        for tool_call in last_message.get("tool_calls", []):
+            tool_name_to_use = tool_call.get("function", {}).get("name")
+            tool_to_use = self.tool_set.get(tool_name_to_use, None)
+            if tool_to_use is None:
                 logging.info("LLM just used an non-existent tool!")
                 continue
 
-            logging.info(f"Running tool: {tool_call.function.name}")
+            logging.info(f"Running tool: {tool_name_to_use}")
             try:
-                tool_kwargs = json.loads(tool_call.function.arguments)
-                tooling_output = tooling_to_use.execute(**tool_kwargs)
+                tool_arguments = tool_call.get("function", {}).get("arguments", "{}")
+                tool_kwargs = json.loads(tool_arguments)
+                tool_output = tool_to_use.execute(**tool_kwargs)
             except JSONDecodeError:
-                tooling_output = "Arguments must be passed through a valid JSON object"
+                tool_output = "Arguments must be passed through a valid JSON object"
 
-            rv.append({"tool_call_id": tool_call.id, "role": "tool", "content": tooling_output})
+            rv.append({"tool_call_id": tool_call.get("id", ""), "role": "tool", "content": tool_output})
 
         return rv
 

patchwork/steps/ResolveIssue/tools/bash_tool.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Literal
+
+from patchwork.steps.ResolveIssue.tools.tool import Tool
+
+
+class BashTool(Tool, tool_name="bash"):
+    def __init__(self, path: str):
+        super().__init__()
+        self.path = Path(path)
+        self.modified_files = []
+
+    @property
+    def json_schema(self) -> dict:
+        return {
+            "name": "bash",
+            "description": """Run commands in a bash shell
+
+* When invoking this tool, the contents of the "command" parameter does NOT need to be XML-escaped.
+* You don't have access to the internet via this tool.
+* You do have access to a mirror of common linux and python packages via apt and pip.
+* State is persistent across command calls and discussions with the user.
+* To inspect a particular line range of a file, e.g. lines 10-25, try 'sed -n 10,25p /path/to/the/file'.
+* Please avoid commands that may produce a very large amount of output.
+* Please run long lived commands in the background, e.g. 'sleep 10 &' or start a server in the background.""",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "description": "The bash command to run."
+                    }
+                },
+                "required": ["command"]
+            }
+        }
+
+    def execute(
+        self,
+        command: str | None = None,
+        *args,
+        **kwargs,
+    ) -> str:
+        """Execute editor commands on files in the repository."""
+        if command is None:
+            return f"Error: `command` parameter must be set and cannot be empty"
+
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=self.path,
+                capture_output=True,
+                text=True,
+                timeout=60  # Add timeout for safety
+            )
+            return result.stdout if result.returncode == 0 else f"Error: {result.stderr}"
+        except subprocess.TimeoutExpired:
+            return "Error: Command timed out after 60 seconds"
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    @property
+    def tool_records(self):
+        return dict(modified_files=[{"path": file} for file in self.modified_files])
+
+    def __get_abs_path(self, path: str):
+        abs_path = (self.repo_path / path.lstrip("/")).resolve()
+        if not abs_path.is_relative_to(self.repo_path):
+            raise ValueError(f"Path {path} contains illegal path traversal")
+
+        return abs_path
+
+    def __view(self, path, view_range):
+        abs_path = self.__get_abs_path(path)
+        if not abs_path.exists():
+            return f"Error: Path {path} does not exist"
+
+        if abs_path.is_file():
+            with open(abs_path, "r") as f:
+                content = f.read()
+
+            if view_range:
+                lines = content.splitlines()
+                start, end = view_range
+                content = "\n".join(lines[start - 1 : end])
+            return content
+        elif abs_path.is_dir():
+            result = []
+            for root, dirs, files in os.walk(abs_path):
+                level = root[len(abs_path) :].count(os.sep)
+                if level <= 2:
+                    for d in dirs:
+                        result.append(d)
+                    for f in files:
+                        result.append(f)
+            return "\n".join(result)
+
+    def __create(self, file_text, path):
+        abs_path = self.__get_abs_path(path)
+        if abs_path.exists():
+            return f"Error: File {path} already exists"
+        abs_path.parent.mkdir(parents=True, exist_ok=True)
+        abs_path.write_text(file_text)
+        return f"File created successfully at: {path}"
+
+    def __str_replace(self, new_str, old_str, path):
+        abs_path = self.__get_abs_path(path)
+        if not abs_path.exists():
+            return f"Error: File {path} does not exist"
+        if not abs_path.is_file():
+            return f"Error: File {path} is not a file"
+        content = abs_path.read_text()
+        occurrences = content.count(old_str)
+        if occurrences != 1:
+            return f"Error: Found {occurrences} occurrences of old_str, expected exactly 1"
+        new_content = content.replace(old_str, new_str)
+        with open(abs_path, "w") as f:
+            f.write(new_content)
+        return "Replacement successful"
+
+    def __insert(self, insert_line, new_str, path):
+        abs_path = self.__get_abs_path(path)
+        if not abs_path.is_file():
+            return f"Error: File {path} does not exist or is not a file"
+
+        lines = abs_path.read_text().splitlines(keepends=True)
+        if insert_line is None or insert_line < 1 or insert_line > len(lines):
+            return f"Error: Invalid insert line {insert_line}"
+
+        lines.insert(insert_line, new_str + "\n")
+        abs_path.write_text("".join(lines))
+        return "Insert successful"

patchwork/steps/ResolveIssue/tools/code_edit_tools.py

@@ -7,10 +7,10 @@
 from patchwork.steps.ResolveIssue.tools.tool import Tool
 
 
-class CodeEditTool(Tool):
-    def __init__(self, repo_path: Path):
+class CodeEditTool(Tool, tool_name="code_edit_tool"):
+    def __init__(self, path: str):
         super().__init__()
-        self.repo_path = repo_path
+        self.repo_path = Path(path)
         self.modified_files = []
 
     @property

patchwork/steps/ResolveIssue/tools/tool.py

@@ -6,7 +6,7 @@ class Tool(ABC):
     __internal_map: dict[str, Type["Tool"]] = dict()
 
     def __init_subclass__(cls, **kwargs):
-        cls_name = kwargs.get("name", cls.__name__)
+        cls_name = kwargs.get("tool_name", cls.__name__)
         if cls_name in cls.__internal_map.keys():
             raise ValueError(f"Duplicate subclass name for class {cls.__name__}: {cls_name}")
         cls.name = cls_name
@@ -24,7 +24,7 @@ def execute(self, *args, **kwargs) -> str:
     @staticmethod
     def get_tools(**kwargs) -> dict[str, "Tool"]:
         rv = dict()
-        for k, v in kwargs.items():
+        for k, v in Tool.__internal_map.items():
             try:
                 rv[k] = v(**kwargs)
             except Exception as e:

poetry.lock

@@ -41,14 +41,13 @@ requests = "~2.31.0"
 chardet = "~5.2.0"
 attrs = "~23.2.0"
 google-generativeai = "~0.8.1"
-anthropic = "~0.34.2"
+anthropic = "~0.40.0"
 rich = "~13.7.1"
 chevron = "~0.14.0"
 giturlparse = "~0.12.0"
 scikit-learn = "^1.3.2"
 json-repair = "~0.30.0"
 # pinning transitive dependencies
-httpx = "<0.28.0"
 tree-sitter = "~0.21.3"
 numpy = [
     { version = "^1.26", python = "^3.12", optional = true},