gptdiff 0.1.28__py3-none-any.whl → 0.1.31__py3-none-any.whl

gptdiff/applydiff.py

@@ -7,6 +7,7 @@ Contains the function to apply unified git diffs to files on disk.
 from pathlib import Path
 import re
 import hashlib
+from collections import defaultdict
 
 def apply_diff(project_dir, diff_text):
     """
@@ -191,6 +192,12 @@ def parse_diff_per_file(diff_text):
         Uses 'b/' prefix detection from git diffs to determine target paths
         This doesn't work all the time and needs to be revised with stronger models
     """
+    def dedup_diffs(diffs):
+        groups = defaultdict(list)
+        for key, value in diffs:
+            groups[key].append(value)
+        return [[key, "\n".join(values)] for key, values in groups.items()]
+
     header_re = re.compile(r'^(?:diff --git\s+)?(a/[^ ]+)\s+(b/[^ ]+)\s*$', re.MULTILINE)
     lines = diff_text.splitlines()
 
@@ -227,7 +234,7 @@ def parse_diff_per_file(diff_text):
             if deletion_mode and not any(l.startswith("+++ ") for l in current_lines):
                 current_lines.append("+++ /dev/null")
             diffs.append((current_file, "\n".join(current_lines)))
-        return diffs
+        return dedup_diffs(diffs)
     else:
         # Use header-based strategy.
         diffs = []
@@ -260,6 +267,6 @@ def parse_diff_per_file(diff_text):
             if deletion_mode and not any(l.startswith("+++ ") for l in current_lines):
                 current_lines.append("+++ /dev/null")
             diffs.append((current_file, "\n".join(current_lines)))
-        return diffs
+        return dedup_diffs(diffs)
 
 

gptdiff/gptdiff.py

@@ -20,6 +20,7 @@ from threading import Lock
 import openai
 from openai import OpenAI
 import tiktoken
+import requests
 import time
 import os
 import json
@@ -35,13 +36,14 @@ from ai_agent_toolbox import MarkdownParser, MarkdownPromptFormatter, Toolbox, F
 from .applydiff import apply_diff, parse_diff_per_file
 
 VERBOSE = False
-diff_context = contextvars.ContextVar('diffcontent', default="")
+diff_context = contextvars.ContextVar('diffcontent', default=[])
 
 def create_diff_toolbox():
     toolbox = Toolbox()
+    diff_context.set([])
     
     def diff(content: str):
-        diff_context.set(content)
+        diff_context.set(diff_context.get()+[content])
         return content
 
     toolbox.add_tool(
@@ -218,7 +220,105 @@ def domain_for_url(base_url):
         domain = base_url
     return domain
 
-def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperature=0.7, max_tokens=30000, api_key=None, base_url=None):
+def call_llm(api_key, base_url, model, messages, max_tokens, temperature, budget_tokens=None):
+    # Check if we're using Anthropic
+    if "api.anthropic.com" in base_url:
+        anthropic_url = "https://api.anthropic.com/v1/messages"
+        
+        headers = {
+            "x-api-key": api_key,
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01"
+        }
+        
+        # Extract system message if present
+        system_message = None
+        filtered_messages = []
+        
+        for message in messages:
+            if message["role"] == "system":
+                system_message = message["content"]
+            else:
+                filtered_messages.append(message)
+        
+        # Prepare request data
+        data = {
+            "model": model,
+            "messages": filtered_messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature
+        }
+        
+        # Add system message as top-level parameter if found
+        if system_message:
+            data["system"] = system_message
+
+        if budget_tokens:
+            data["temperature"] = 1
+            data["thinking"] = {"budget_tokens": budget_tokens, "type": "enabled"}
+        
+        # Make the API call
+        response = requests.post(anthropic_url, headers=headers, json=data)
+        response_data = response.json()
+        
+        if 'error' in response_data:
+            print(f"Error from Anthropic API: {response_data}")
+            return response_data
+        
+        # Format response to match OpenAI structure for compatibility
+        class OpenAICompatResponse:
+            class Choice:
+                class Message:
+                    def __init__(self, content):
+                        self.content = content
+                
+                def __init__(self, message):
+                    self.message = message
+            
+            class Usage:
+                def __init__(self, prompt_tokens, completion_tokens, total_tokens):
+                    self.prompt_tokens = prompt_tokens
+                    self.completion_tokens = completion_tokens
+                    self.total_tokens = total_tokens
+            
+            def __init__(self, choices, usage):
+                self.choices = choices
+                self.usage = usage
+        
+        # Get content from the response
+        thinking_items = [item["thinking"] for item in response_data["content"] if item["type"] == "thinking"]
+        text_items = [item["text"] for item in response_data["content"] if item["type"] == "text"]
+        if not text_items:
+            raise ValueError("No 'text' type found in response content")
+        text_content = text_items[0]
+        if thinking_items:
+            wrapped_thinking = f"<think>{thinking_items[0]}</think>"
+            message_content = wrapped_thinking + "\n" + text_content
+        else:
+            message_content = text_content
+        
+        # Extract token usage information
+        input_tokens = response_data["usage"]["input_tokens"]
+        output_tokens = response_data["usage"]["output_tokens"]
+        total_tokens = input_tokens + output_tokens
+        
+        # Create the response object with usage information
+        message = OpenAICompatResponse.Choice.Message(message_content)
+        choice = OpenAICompatResponse.Choice(message)
+        usage = OpenAICompatResponse.Usage(input_tokens, output_tokens, total_tokens)
+        
+        return OpenAICompatResponse([choice], usage)
+    else:
+        # Use OpenAI client as before
+        client = OpenAI(api_key=api_key, base_url=base_url)
+        return client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+
+def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperature=1.0, max_tokens=30000, api_key=None, base_url=None, budget_tokens=None):
     enc = tiktoken.get_encoding("o200k_base")
     
     # Use colors in print statements
@@ -258,13 +358,16 @@ def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperat
     if not base_url:
         base_url = os.getenv('GPTDIFF_LLM_BASE_URL', "https://nano-gpt.com/api/v1/")
     base_url = base_url or "https://nano-gpt.com/api/v1/"
-    
-    client = OpenAI(api_key=api_key, base_url=base_url)
-    response = client.chat.completions.create(model=model,
+
+    response = call_llm(
+        api_key=api_key,
+        base_url=base_url,
+        model=model,
         messages=messages,
         max_tokens=max_tokens,
-        temperature=temperature)
-
+        budget_tokens=budget_tokens,
+        temperature=temperature
+    )
     if VERBOSE:
         print("Debug: Raw LLM Response\n---")
         print(response.choices[0].message.content.strip())
@@ -294,7 +397,7 @@ def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperat
         toolbox.use(event)
     diff_response = diff_context.get()
 
-    return full_response, diff_response, prompt_tokens, completion_tokens, total_tokens
+    return full_response, "\n".join(diff_response), prompt_tokens, completion_tokens, total_tokens
 
 # New API functions
 def build_environment(files_dict):
@@ -306,7 +409,7 @@ def build_environment(files_dict):
         env.append(content)
     return '\n'.join(env)
 
-def generate_diff(environment, goal, model=None, temperature=0.7, max_tokens=32000, api_key=None, base_url=None, prepend=None):
+def generate_diff(environment, goal, model=None, temperature=1.0, max_tokens=32000, api_key=None, base_url=None, prepend=None, anthropic_budget_tokens=None):
     """API: Generate a git diff from the environment and goal.
 
 If 'prepend' is provided, it should be a path to a file whose content will be
@@ -314,6 +417,10 @@ prepended to the system prompt.
     """
     if model is None:
         model = os.getenv('GPTDIFF_MODEL', 'deepseek-reasoner')
+        # Use ANTHROPIC_BUDGET_TOKENS env var if set and no cli override provided
+        if anthropic_budget_tokens is None:
+            anthropic_budget_tokens = os.getenv('ANTHROPIC_BUDGET_TOKENS')
+    
     if prepend:
         if prepend.startswith("http://") or prepend.startswith("https://"):
             import urllib.request
@@ -326,15 +433,16 @@ prepended to the system prompt.
     
     diff_tag = "```diff"
     system_prompt = prepend + f"Output a git diff into a \"{diff_tag}\" block."
-    _, diff_text, _, _, _, _ = call_llm_for_diff(
+    _, diff_text, _, _, _ = call_llm_for_diff(
         system_prompt, 
         goal, 
         environment, 
-        model=model,
+        model,
+        temperature=temperature,
+        max_tokens=max_tokens,
         api_key=api_key,
         base_url=base_url,
-        max_tokens=max_tokens,
-        temperature=temperature
+        budget_tokens=int(anthropic_budget_tokens) if anthropic_budget_tokens is not None else None
     )
     return diff_text
 
@@ -416,11 +524,12 @@ def parse_arguments():
     parser.add_argument('--call', action='store_true',
                         help='Call the GPT-4 API. Writes the full prompt to prompt.txt if not specified.')
     parser.add_argument('files', nargs='*', default=[], help='Specify additional files or directories to include.')
-    parser.add_argument('--temperature', type=float, default=0.7, help='Temperature parameter for model creativity (0.0 to 2.0)')
+    parser.add_argument('--temperature', type=float, default=1.0, help='Temperature parameter for model creativity (0.0 to 2.0)')
     parser.add_argument('--max_tokens', type=int, default=30000, help='Temperature parameter for model creativity (0.0 to 2.0)')
     parser.add_argument('--model', type=str, default=None, help='Model to use for the API call.')
     parser.add_argument('--applymodel', type=str, default=None, help='Model to use for applying the diff. Defaults to the value of --model if not specified.')
     parser.add_argument('--nowarn', action='store_true', help='Disable large token warning')
+    parser.add_argument('--anthropic_budget_tokens', type=int, default=None, help='Budget tokens for Anthropic extended thinking')
     parser.add_argument('--verbose', action='store_true', help='Enable verbose output with detailed information')
     return parser.parse_args()
 
@@ -768,20 +877,13 @@ def main():
             if confirmation != 'y':
                 print("Request canceled")
                 sys.exit(0)
-        try:
-            full_text, diff_text, prompt_tokens, completion_tokens, total_tokens = call_llm_for_diff(system_prompt, user_prompt, files_content, args.model, 
-                                                                                                    temperature=args.temperature,
-                                                                                                    api_key=os.getenv('GPTDIFF_LLM_API_KEY'),
-                                                                                                    base_url=os.getenv('GPTDIFF_LLM_BASE_URL', "https://nano-gpt.com/api/v1/"),
-                                                                                                    max_tokens=args.max_tokens
-                                                                                                    ) 
-        except Exception as e:
-            full_text = f"{e}"
-            diff_text = ""
-            prompt_tokens = 0
-            completion_tokens = 0
-            total_tokens = 0
-            print(f"Error in LLM response {e}")
+        full_text, diff_text, prompt_tokens, completion_tokens, total_tokens = call_llm_for_diff(system_prompt, user_prompt, files_content, args.model, 
+                                                                                                temperature=args.temperature,
+                                                                                                api_key=os.getenv('GPTDIFF_LLM_API_KEY'),
+                                                                                                base_url=os.getenv('GPTDIFF_LLM_BASE_URL', "https://nano-gpt.com/api/v1/"),
+                                                                                                max_tokens=args.max_tokens,
+                                                                                                budget_tokens=args.anthropic_budget_tokens
+                                                                                                ) 
 
     if(diff_text.strip() == ""):
         print(f"\033[1;33mWarning: No valid diff data was generated. This could be due to an unclear prompt or an invalid LLM response.\033[0m")
@@ -831,20 +933,17 @@ def swallow_reasoning(full_response: str) -> (str, str):
         r"(?P<reasoning>>\s*Reasoning.*?Reasoned.*?seconds)",
         re.DOTALL
     )
-    match = pattern.search(full_response)
-    if match:
+    reasoning_list = []
+    def replacer(match):
         raw_reasoning = match.group("reasoning")
-        # Remove any leading '+' characters and extra whitespace from each line
         reasoning_lines = [line.lstrip('+').strip() for line in raw_reasoning.splitlines()]
         reasoning = "\n".join(reasoning_lines).strip()
-
-        # Remove the reasoning block from the response using its exact span
-        final_content = full_response[:match.start()] + full_response[match.end():]
-        final_content = final_content.strip()
-    else:
-        reasoning = ""
-        final_content = full_response.strip()
-    return final_content, reasoning
+        reasoning_list.append(reasoning)
+        return ""
+    
+    final_content = re.sub(pattern, replacer, full_response)
+    reasoning = "\n".join(reasoning_list)
+    return final_content.strip(), reasoning
 
 def strip_bad_output(updated: str, original: str) -> str:
     """

{gptdiff-0.1.28.dist-info → gptdiff-0.1.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.28
+Version: 0.1.31
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License
@@ -31,30 +31,48 @@ GPTDiff: Create and apply diffs using AI.
 This tool leverages natural language instructions to modify project codebases.
 -->
 
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Example Usage](#example-usage-of-gptdiff)
+- [Basic Usage](#basic-usage)
+- [Simple Command Line Agent Loops](#simple-command-line-agent-loops)
+- [Why Choose GPTDiff?](#why-choose-gptdiff)
+- [Core Capabilities](#core-capabilities)
+  - [CLI Excellence](#-cli-excellence)
+  - [Magic Diff Generation](#-magic-diff-generation)
+  - [Smart Apply System](#-smart-apply-system)
+- [Get Started](#get-started)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+- [Command Line Usage](#command-line-usage)
+
 🚀 **Create and apply diffs with AI**  
 Modify your project using plain English.
 
-More documentation at [gptdiff.255labs.xyz](gptdiff.255labs.xyz)
+More documentation at [gptdiff.255labs.xyz](https://gptdiff.255labs.xyz)
+
+## Quick Start
 
+1. **Install GPTDiff**
+   
+   
 ### Example Usage of `gptdiff`
 
 #### Apply a Patch Directly
-```
-bash
+```bash
 gptdiff "Add button animations on press" --apply
 ```
 ✅ Successfully applied patch
 
 #### Generate a Patch File
-```
-bash
+```bash
 gptdiff "Add API documentation" --call
 ```
 🔧 Patch written to `diff.patch`
 
 #### Generate a Prompt File Without Calling LLM
-```
-bash
+```bash
 gptdiff "Improve error messages"
 ```
 📄 LLM not called, written to `prompt.txt`

gptdiff-0.1.31.dist-info/RECORD

@@ -0,0 +1,10 @@
+gptdiff/__init__.py,sha256=o1hrK4GFvbfKcHPlLVArz4OunE3euIicEBYaLrdDo0k,198
+gptdiff/applydiff.py,sha256=FMLkEtNnOdnU7c8LgYafGuROsDz3utpyXKJVFRs_BvI,11473
+gptdiff/gptdiff.py,sha256=EC2PpES2NchJvcTtNo0U0CfKLH9DdV86OuzOzLCyTr8,37424
+gptdiff/gptpatch.py,sha256=Vqk2vliYs_BxtuTpwdS88n3A8XToh6RvrCA4N8VqOu0,2759
+gptdiff-0.1.31.dist-info/LICENSE.txt,sha256=zCJk7yUYpMjFvlipi1dKtaljF8WdZ2NASndBYYbU8BY,1228
+gptdiff-0.1.31.dist-info/METADATA,sha256=YPye_cME35OcmzklE__dMLncBYY9bhdjKf7j9wczChU,9343
+gptdiff-0.1.31.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+gptdiff-0.1.31.dist-info/entry_points.txt,sha256=0VlVNr-gc04a3SZD5_qKIBbtg_L5P2x3xlKE5ftcdkc,82
+gptdiff-0.1.31.dist-info/top_level.txt,sha256=XNkQkQGINaDndEwRxg8qToOrJ9coyfAb-EHrSUXzdCE,8
+gptdiff-0.1.31.dist-info/RECORD,,

{gptdiff-0.1.28.dist-info → gptdiff-0.1.31.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gptdiff-0.1.28.dist-info/RECORD

@@ -1,10 +0,0 @@
-gptdiff/__init__.py,sha256=o1hrK4GFvbfKcHPlLVArz4OunE3euIicEBYaLrdDo0k,198
-gptdiff/applydiff.py,sha256=_11ITFMcigwvVptaIpEtyfLUTIy_mYPWExcXUqCBfOs,11200
-gptdiff/gptdiff.py,sha256=Lf3utjFM0T-39YyfMXUHZmVzukJk1DxR9941KNcYyIs,33373
-gptdiff/gptpatch.py,sha256=Vqk2vliYs_BxtuTpwdS88n3A8XToh6RvrCA4N8VqOu0,2759
-gptdiff-0.1.28.dist-info/LICENSE.txt,sha256=zCJk7yUYpMjFvlipi1dKtaljF8WdZ2NASndBYYbU8BY,1228
-gptdiff-0.1.28.dist-info/METADATA,sha256=iqKGOSe6vN62loiZ6vA2UZG-fAE80I_ZxHjMHs8CC_E,8723
-gptdiff-0.1.28.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-gptdiff-0.1.28.dist-info/entry_points.txt,sha256=0VlVNr-gc04a3SZD5_qKIBbtg_L5P2x3xlKE5ftcdkc,82
-gptdiff-0.1.28.dist-info/top_level.txt,sha256=XNkQkQGINaDndEwRxg8qToOrJ9coyfAb-EHrSUXzdCE,8
-gptdiff-0.1.28.dist-info/RECORD,,