patchllm 0.2.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

patchllm/agent/actions.py

@@ -0,0 +1,73 @@
+import subprocess
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+def run_tests():
+    """
+    Runs tests using pytest and displays the output.
+    """
+    console.print("\n--- Running Tests ---", style="bold yellow")
+    try:
+        process = subprocess.run(
+            ["pytest"],
+            capture_output=True,
+            text=True,
+            check=False  # We don't want to crash if tests fail
+        )
+        
+        output = process.stdout + process.stderr
+        
+        if process.returncode == 0:
+            title = "[bold green]✅ Tests Passed[/bold green]"
+            border_style = "green"
+        else:
+            title = "[bold red]❌ Tests Failed[/bold red]"
+            border_style = "red"
+            
+        console.print(Panel(output, title=title, border_style=border_style, expand=True))
+
+    except FileNotFoundError:
+        console.print("❌ 'pytest' command not found. Is it installed and in your PATH?", style="red")
+    except Exception as e:
+        console.print(f"❌ An unexpected error occurred while running tests: {e}", style="red")
+
+
+def stage_files(files_to_stage: list[str] = None):
+    """
+    Stages files using git. If no files are specified, stages all changes.
+
+    Args:
+        files_to_stage (list[str], optional): A list of specific files to stage. Defaults to None.
+    """
+    command = ["git", "add"]
+    action_desc = "all changes"
+    if files_to_stage:
+        command.extend(files_to_stage)
+        action_desc = f"{len(files_to_stage)} file(s)"
+    else:
+        command.append(".")
+
+    console.print(f"\n--- Staging {action_desc} ---", style="bold yellow")
+    try:
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        output = process.stdout + process.stderr
+        if output:
+            console.print(output, style="dim")
+            
+        console.print("✅ Files staged successfully.", style="green")
+
+    except FileNotFoundError:
+        console.print("❌ 'git' command not found. Is it installed and in your PATH?", style="red")
+    except subprocess.CalledProcessError as e:
+        console.print("❌ Failed to stage files.", style="red")
+        console.print(e.stderr)
+    except Exception as e:
+        console.print(f"❌ An unexpected error occurred while staging files: {e}", style="red")

patchllm/agent/executor.py

@@ -0,0 +1,57 @@
+from ..llm import run_llm_query
+from ..parser import summarize_changes, get_diff_for_file, parse_change_summary
+
+def execute_step(step_instruction: str, history: list[dict], context: str | None, context_images: list | None, model_name: str) -> dict | None:
+    """
+    Executes a single step of the plan by calling the LLM.
+
+    Args:
+        step_instruction (str): The instruction for the current step.
+        history (list[dict]): The full conversation history.
+        context (str | None): The file context for the LLM.
+        context_images (list | None): A list of image data dictionaries for multimodal context.
+        model_name (str): The name of the LLM to use.
+
+    Returns:
+        A dictionary containing the instruction, response, and diffs, or None if it fails.
+    """
+    
+    prompt_text = f"## Current Task:\n{step_instruction}"
+    if context:
+        prompt_text = f"## Context:\n{context}\n\n---\n\n{prompt_text}"
+    
+    user_content = [{"type": "text", "text": prompt_text}]
+
+    if context_images:
+        for image_info in context_images:
+            user_content.append({
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:{image_info['mime_type']};base64,{image_info['content_base64']}"
+                }
+            })
+
+    # Create a temporary message history for this specific call
+    messages = history + [{"role": "user", "content": user_content}]
+    
+    llm_response = run_llm_query(messages, model_name)
+    
+    if not llm_response:
+        return None
+    
+    change_summary = parse_change_summary(llm_response)
+    summary = summarize_changes(llm_response)
+    all_files = summary.get("modified", []) + summary.get("created", [])
+    
+    diffs = []
+    for file_path in all_files:
+        diff_text = get_diff_for_file(file_path, llm_response)
+        diffs.append({"file_path": file_path, "diff_text": diff_text})
+        
+    return {
+        "instruction": step_instruction,
+        "llm_response": llm_response,
+        "summary": summary,
+        "diffs": diffs,
+        "change_summary": change_summary,
+    }

patchllm/agent/planner.py

@@ -0,0 +1,76 @@
+import re
+from ..llm import run_llm_query
+
+def _get_planning_prompt(goal: str, context_tree: str) -> list[dict]:
+    """Constructs the initial prompt for the planning phase."""
+    
+    system_prompt = (
+        "You are an expert software architect. Your task is to create a high-level, milestone-focused plan to "
+        "accomplish a user's goal. Break down the goal into logical, sequential steps that represent significant "
+        "pieces of functionality or architectural changes."
+        "\n\n"
+        "IMPORTANT RULES:\n"
+        "- DO NOT list individual file modifications. Instead, group related changes into a single milestone.\n"
+        "- For example, instead of a plan like '1. Add route to api.py, 2. Create logic in services.py', a better, "
+        "milestone-focused step would be '1. Implement the user authentication endpoint, including routes and server actions'.\n"
+        "- Do not write any code or implementation details in the plan.\n"
+        "- Each step should be a clear, actionable instruction for a developer.\n"
+        "- The final plan must be a numbered list."
+    )
+    
+    user_prompt = (
+        "Based on my goal and the project structure below, create your plan.\n\n"
+        f"## Project Structure:\n```\n{context_tree}\n```\n\n"
+        f"## Goal:\n{goal}"
+    )
+    
+    return [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt}
+    ]
+
+def _get_refine_prompt(history: list[dict], feedback: str) -> list[dict]:
+    """Constructs the prompt for refining an existing plan."""
+    refine_instruction = (
+        "The user has provided feedback or a new idea on the plan you created. "
+        "Carefully review the entire conversation and their latest feedback. "
+        "Your task is to generate a new, complete, and improved step-by-step plan that incorporates their feedback. "
+        "The new plan should be a single, cohesive, numbered list. Do not just add to the old plan; create a new one from scratch."
+        f"\n\n## User Feedback:\n{feedback}"
+    )
+    
+    return history + [{"role": "user", "content": refine_instruction}]
+
+def parse_plan_from_response(response_text: str) -> list[str] | None:
+    """Finds all lines that start with a number and a period (e.g., "1.", "2.")."""
+    if not response_text:
+        return None
+    # This is more robust than splitting by newline.
+    plan = re.findall(r"^\s*\d+\.\s+(.*)", response_text, re.MULTILINE)
+    return plan if plan else None
+
+def generate_plan_and_history(goal: str, context_tree: str, model_name: str) -> tuple[list[dict], str | None]:
+    """
+    Calls the LLM to generate an initial plan and returns the history and response.
+
+    Returns:
+        A tuple containing the initial planning history (list of messages) and the LLM's raw response text.
+    """
+    messages = _get_planning_prompt(goal, context_tree)
+    response_text = run_llm_query(messages, model_name)
+    
+    if response_text:
+        messages.append({"role": "assistant", "content": response_text})
+    
+    return messages, response_text
+
+def generate_refined_plan(history: list[dict], feedback: str, model_name: str) -> str | None:
+    """
+    Calls the LLM to refine a plan based on conversation history and new feedback.
+
+    Returns:
+        The LLM's raw response text containing the new plan.
+    """
+    messages = _get_refine_prompt(history, feedback)
+    response_text = run_llm_query(messages, model_name)
+    return response_text

patchllm/agent/session.py

@@ -0,0 +1,425 @@
+from pathlib import Path
+import json
+import os
+
+from ..cli.helpers import get_system_prompt
+
+CONFIG_FILE_PATH = Path(".patchllm_config.json")
+
+class AgentSession:
+    """
+    Manages the state for a continuous, interactive agent session.
+    """
+    def __init__(self, args, scopes: dict, recipes: dict):
+        self.args = args
+        self.goal: str | None = None
+        self.plan: list[str] = []
+        self.current_step: int = 0
+        self.context: str | None = None
+        self.context_files: list[Path] = []
+        self.context_images: list = []
+        self.history: list[dict] = [{"role": "system", "content": get_system_prompt()}]
+        self.planning_history: list[dict] = []
+        self.scopes = scopes
+        self.recipes = recipes
+        self.last_execution_result: dict | None = None
+        self.action_history: list[str] = []
+        self.last_revert_state: list[dict] = []
+        self.api_keys: dict = {}
+        self.load_settings()
+
+    def load_settings(self):
+        """Loads settings from the config file and applies them."""
+        if CONFIG_FILE_PATH.exists():
+            try:
+                with open(CONFIG_FILE_PATH, 'r') as f:
+                    settings = json.load(f)
+                
+                if 'model' in settings:
+                    self.args.model = settings['model']
+
+                self.api_keys = settings.get('api_keys', {})
+                for key, value in self.api_keys.items():
+                    if key not in os.environ:
+                        os.environ[key] = value
+
+            except (json.JSONDecodeError, IOError):
+                pass
+
+    def save_settings(self):
+        """Saves current settings to the config file."""
+        settings_to_save = {
+            'model': self.args.model,
+            'api_keys': self.api_keys
+        }
+        with open(CONFIG_FILE_PATH, 'w') as f:
+            json.dump(settings_to_save, f, indent=2)
+
+    def set_api_key(self, key_name: str, key_value: str):
+        """Sets an API key, applies it to the environment, and saves it."""
+        self.api_keys[key_name] = key_value
+        os.environ[key_name] = key_value
+        self.save_settings()
+
+    def remove_api_key(self, key_name: str):
+        """Removes an API key and saves the settings."""
+        if key_name in self.api_keys:
+            del self.api_keys[key_name]
+            self.save_settings()
+
+    def to_dict(self) -> dict:
+        """Serializes the session's state to a dictionary."""
+        return {
+            "goal": self.goal,
+            "plan": self.plan,
+            "current_step": self.current_step,
+            "context_files": [p.as_posix() for p in self.context_files],
+            "action_history": self.action_history,
+            "last_revert_state": self.last_revert_state,
+        }
+
+    def from_dict(self, data: dict):
+        """Restores the session's state from a dictionary."""
+        self.goal = data.get("goal")
+        self.plan = data.get("plan", [])
+        self.current_step = data.get("current_step", 0)
+        self.action_history = data.get("action_history", [])
+        self.last_revert_state = data.get("last_revert_state", [])
+        
+        context_file_paths = data.get("context_files", [])
+        if context_file_paths:
+            self.add_files_and_rebuild_context([Path(p) for p in context_file_paths])
+
+    def set_goal(self, goal: str):
+        self.goal = goal
+        self.plan = []
+        self.current_step = 0
+        self.planning_history = []
+        self.action_history.append(f"Goal set: {goal}")
+
+    def edit_plan_step(self, step_number: int, new_instruction: str) -> bool:
+        """Edits an instruction in the current plan."""
+        if 1 <= step_number <= len(self.plan):
+            self.plan[step_number - 1] = new_instruction
+            return True
+        return False
+
+    def remove_plan_step(self, step_number: int) -> bool:
+        """Removes a step from the current plan."""
+        if 1 <= step_number <= len(self.plan):
+            del self.plan[step_number - 1]
+            if step_number - 1 < self.current_step:
+                self.current_step -=1
+            return True
+        return False
+
+    def add_plan_step(self, instruction: str):
+        """Adds a new instruction to the end of the plan."""
+        self.plan.append(instruction)
+
+    def skip_step(self) -> bool:
+        """Skips the current step and moves to the next one."""
+        if self.current_step < len(self.plan):
+            self.current_step += 1
+            self.last_execution_result = None
+            return True
+        return False
+
+    def create_plan(self) -> bool:
+        from ..scopes.builder import helpers
+        from . import planner
+        
+        if not self.goal: return False
+        context_tree = helpers.generate_source_tree(Path(".").resolve(), self.context_files)
+        
+        self.planning_history, plan_response = planner.generate_plan_and_history(self.goal, context_tree, self.args.model)
+        
+        if plan_response:
+            parsed_plan = planner.parse_plan_from_response(plan_response)
+            if parsed_plan:
+                self.plan = parsed_plan
+                self.action_history.append("Plan generated.")
+                return True
+        return False
+
+    def ask_question(self, question: str) -> str | None:
+        """Asks a clarifying question about the plan or the context."""
+        from ..llm import run_llm_query
+
+        prompt_text = (
+            "Based on our conversation so far, please answer my question.\n\n"
+            f"## My Question\n{question}"
+        )
+
+        if self.context:
+            prompt_text = (
+                "Based on the provided context and our conversation so far, please answer my question.\n\n"
+                f"## Code Context\n{self.context}\n\n---\n\n"
+                f"## My Question\n{question}"
+            )
+        
+        user_content = [{"type": "text", "text": prompt_text}]
+
+        if self.context_images:
+            for image_info in self.context_images:
+                user_content.append({
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:{image_info['mime_type']};base64,{image_info['content_base64']}"
+                    }
+                })
+
+        messages = self.planning_history + [{"role": "user", "content": user_content}]
+        response = run_llm_query(messages, self.args.model)
+
+        if response:
+            self.planning_history.append({"role": "assistant", "content": response})
+        
+        return response
+
+    def refine_plan(self, feedback: str) -> bool:
+        """Refines the existing plan based on user feedback."""
+        from . import planner
+
+        new_plan_response = planner.generate_refined_plan(self.planning_history, feedback, self.args.model)
+        if new_plan_response:
+            parsed_plan = planner.parse_plan_from_response(new_plan_response)
+            if parsed_plan:
+                self.planning_history.append({"role": "user", "content": feedback})
+                self.planning_history.append({"role": "assistant", "content": new_plan_response})
+                self.plan = parsed_plan
+                return True
+        return False
+
+    def run_next_step(self, instruction_override: str | None = None) -> dict | None:
+        from . import executor
+        
+        if not self.plan or self.current_step >= len(self.plan): return None
+        step_instruction = instruction_override or self.plan[self.current_step]
+        result = executor.execute_step(step_instruction, self.history, self.context, self.context_images, self.args.model)
+        if result: self.last_execution_result = result
+        return result
+
+    def run_all_remaining_steps(self) -> dict | None:
+        """Combines all remaining steps into a single execution call."""
+        from . import executor
+
+        if not self.plan or self.current_step >= len(self.plan): return None
+        
+        remaining_steps = self.plan[self.current_step:]
+        if not remaining_steps: return None
+
+        formatted_steps = "\n".join(f"{i + 1}. {step}" for i, step in enumerate(remaining_steps))
+        combined_instruction = (
+            "Please execute the following remaining steps of the plan in a single pass. "
+            "Ensure you provide the full, final content for every file you modify.\n\n"
+            f"--- Remaining Steps ---\n{formatted_steps}"
+        )
+
+        result = executor.execute_step(combined_instruction, self.history, self.context, self.context_images, self.args.model)
+        
+        if result:
+            self.last_execution_result = result
+            self.last_execution_result['is_multi_step'] = True 
+        return result
+
+    def run_goal_directly(self) -> dict | None:
+        """Executes the user's goal directly without a plan."""
+        from . import executor
+
+        if not self.goal: return None
+
+        combined_instruction = (
+            "Please achieve the following goal in a single pass. "
+            "Ensure you provide the full, final content for every file you modify.\n\n"
+            f"--- Goal ---\n{self.goal}"
+        )
+
+        result = executor.execute_step(combined_instruction, self.history, self.context, self.context_images, self.args.model)
+        
+        if result:
+            self.last_execution_result = result
+            self.last_execution_result['is_planless_run'] = True 
+        return result
+
+    def approve_changes(self, files_to_approve: list[str]) -> bool:
+        """
+        Applies changes from the last execution, either fully or partially.
+        Returns True if all changes were applied, False otherwise.
+        """
+        from ..parser import paste_response_selectively, _parse_file_blocks
+        
+        if not self.last_execution_result: return False
+
+        all_proposed_files = self.last_execution_result.get("summary", {}).get("modified", []) + \
+                             self.last_execution_result.get("summary", {}).get("created", [])
+        
+        revert_state = []
+        parsed_blocks = _parse_file_blocks(self.last_execution_result["llm_response"])
+
+        for file_path_str in files_to_approve:
+            file_path = Path(file_path_str)
+            if file_path.exists():
+                try:
+                    original_content = file_path.read_text(encoding="utf-8")
+                    revert_state.append({"file_path": file_path.as_posix(), "content": original_content, "action": "modify"})
+                except Exception:
+                    pass
+            else:
+                revert_state.append({"file_path": file_path.as_posix(), "content": None, "action": "create"})
+        
+        self.last_revert_state = revert_state
+        
+        paste_response_selectively(self.last_execution_result["llm_response"], files_to_approve)
+        
+        is_multi_step = self.last_execution_result.get('is_multi_step', False)
+        is_planless_run = self.last_execution_result.get('is_planless_run', False)
+
+        if is_planless_run:
+            step_log_msg = "plan-less goal execution"
+        else:
+            step_log_msg = f"steps {self.current_step + 1}-{len(self.plan)}" if is_multi_step else f"step {self.current_step + 1}"
+        
+        self.action_history.append(f"Approved {len(files_to_approve)} file(s) for {step_log_msg}.")
+        
+        is_full_approval = len(files_to_approve) == len(all_proposed_files)
+
+        if is_full_approval:
+            instruction_used = self.last_execution_result.get("instruction")
+            if not instruction_used and not is_planless_run:
+                 instruction_used = self.plan[self.current_step]
+
+            user_prompt = f"Context attached.\n\n---\n\nMy task was: {instruction_used}"
+            self.history.append({"role": "user", "content": user_prompt})
+            self.history.append({"role": "assistant", "content": self.last_execution_result["llm_response"]})
+            
+            if not is_planless_run:
+                if is_multi_step:
+                    self.current_step = len(self.plan)
+                else:
+                    self.current_step += 1
+            
+            self.last_execution_result = None
+        else:
+            self.last_execution_result['approved_files'] = files_to_approve
+        
+        return is_full_approval
+
+    def revert_last_approval(self) -> bool:
+        """Writes the stored original content back to the files from the last approval."""
+        if not self.last_revert_state:
+            return False
+
+        for state in self.last_revert_state:
+            file_path = Path(state["file_path"])
+            action = state["action"]
+
+            try:
+                if action == "modify":
+                    file_path.write_text(state["content"], encoding="utf-8")
+                elif action == "create":
+                    if file_path.exists():
+                        file_path.unlink()
+            except Exception as e:
+                print(f"Warning: Could not revert {file_path}: {e}")
+        
+        self.action_history.append("Reverted last approval.")
+        self.last_revert_state = []
+        return True
+
+    def retry_step(self, feedback: str) -> dict | None:
+        """
+        Retries the current step. If a partial approval occurred, it constructs
+        a more detailed prompt informing the LLM of what was approved and rejected.
+        """
+        from . import executor
+
+        is_planless_run = self.last_execution_result and self.last_execution_result.get('is_planless_run', False)
+
+        if not is_planless_run and (not self.plan or self.current_step >= len(self.plan)): return None
+        if is_planless_run and not self.goal: return None
+
+        is_multi_step = self.last_execution_result and self.last_execution_result.get('is_multi_step', False)
+        
+        if is_planless_run:
+            original_instruction = f"to achieve the goal: {self.goal}"
+        else:
+            original_instruction = "to complete the rest of the plan" if is_multi_step else self.plan[self.current_step]
+        
+        if self.last_execution_result and 'approved_files' in self.last_execution_result:
+            approved = self.last_execution_result['approved_files']
+            all_proposed = self.last_execution_result.get("summary", {}).get("modified", []) + \
+                           self.last_execution_result.get("summary", {}).get("created", [])
+            rejected = [f for f in all_proposed if f not in approved]
+
+            refined_instruction = (
+                f"Your previous attempt was partially correct. I have **approved** the changes for the following files:\n"
+                f"- {', '.join(Path(f).name for f in approved)}\n\n"
+                f"However, I **rejected** the changes for these files:\n"
+                f"- {', '.join(Path(f).name for f in rejected)}\n\n"
+                f"Here is my feedback on the rejected files: {feedback}\n\n"
+                f"Please provide a new, corrected version of **only the rejected files** based on this feedback.\n\n"
+                f"---\n\nMy original overall instruction for this step was: {original_instruction}"
+            )
+        else:
+            refined_instruction = (
+                f"My previous attempt was not correct. Here is my feedback: {feedback}\n\n"
+                f"---\n\nMy original instruction was: {original_instruction}"
+            )
+            
+        result = executor.execute_step(refined_instruction, self.history, self.context, self.context_images, self.args.model)
+        if result:
+            self.last_execution_result = result
+            if is_multi_step:
+                self.last_execution_result['is_multi_step'] = True
+            if is_planless_run:
+                self.last_execution_result['is_planless_run'] = True
+        return result
+
+    def reload_scopes(self, scopes_file_path: str):
+        from ..utils import load_from_py_file
+        
+        try:
+            self.scopes = load_from_py_file(scopes_file_path, "scopes")
+        except FileNotFoundError:
+            self.scopes = {}
+        except Exception as e:
+            print(f"Warning: Could not reload scopes file: {e}")
+
+    def load_context_from_scope(self, scope_name: str) -> str:
+        from ..scopes.builder import build_context
+        
+        context_object = build_context(scope_name, self.scopes, Path(".").resolve())
+        if context_object:
+            self.context = context_object.get("context")
+            self.context_files = context_object.get("files", [])
+            self.context_images = context_object.get("images", [])
+            return context_object.get("tree", "Context loaded.")
+        self.clear_context()
+        return f"⚠️  Could not build context for scope '{scope_name}'. No files found."
+
+    def add_files_and_rebuild_context(self, new_files: list[Path]) -> str:
+        from ..scopes.builder import build_context_from_files
+        
+        current_files_set = set(self.context_files)
+        updated_files = sorted(list(current_files_set.union(set(new_files))))
+        context_object = build_context_from_files(updated_files, Path(".").resolve())
+        if context_object:
+            self.context = context_object.get("context")
+            self.context_files = context_object.get("files", [])
+            self.context_images = context_object.get("images", [])
+            return context_object.get("tree", "Context updated.")
+        return "⚠️  Failed to rebuild context with new files."
+
+    def add_context_from_scope(self, scope_name: str) -> str:
+        from ..scopes.builder import build_context
+        
+        context_object = build_context(scope_name, self.scopes, Path(".").resolve())
+        if not context_object or not context_object.get("files"):
+            return f"⚠️  Scope '{scope_name}' resolved to zero files. Context is unchanged."
+        return self.add_files_and_rebuild_context(context_object.get("files", []))
+
+    def clear_context(self):
+        self.context = None
+        self.context_files = []
+        self.context_images = []