gptdiff 0.1.22__tar.gz → 0.1.24__tar.gz

{gptdiff-0.1.22 → gptdiff-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.22
+Version: 0.1.24
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License

gptdiff-0.1.24/gptdiff/applydiff.py

@@ -0,0 +1,264 @@
+"""
+Module: applydiff
+
+Contains the function to apply unified git diffs to files on disk.
+"""
+
+from pathlib import Path
+import re
+import hashlib
+
+def apply_diff(project_dir, diff_text):
+    """
+    Applies a unified diff (as generated by git diff) to the files in project_dir
+    using pure Python (without calling the external 'patch' command).
+
+    Handles file modifications, new file creation, and file deletions.
+
+    Returns:
+        True if at least one file was modified (or deleted/created) as a result of the patch,
+        False otherwise.
+    """
+    from pathlib import Path
+    import re, hashlib
+
+    def file_hash(filepath):
+        h = hashlib.sha256()
+        with open(filepath, "rb") as f:
+            h.update(f.read())
+        return h.hexdigest()
+
+    def apply_patch_to_file(file_path, patch):
+        """
+        Applies a unified diff patch (for a single file) to file_path.
+
+        Returns True if the patch was applied successfully, False otherwise.
+        """
+        # Read the original file lines; if the file doesn't exist, treat it as empty.
+        if file_path.exists():
+            original_lines = file_path.read_text(encoding="utf8").splitlines(keepends=True)
+        else:
+            original_lines = []
+        new_lines = []
+        current_index = 0
+
+        patch_lines = patch.splitlines()
+        # Regex for a hunk header, e.g., @@ -3,7 +3,6 @@
+        hunk_header_re = re.compile(r"^@@(?: -(\d+)(?:,(\d+))?)?(?: \+(\d+)(?:,(\d+))?)? @@")
+        i = 0
+        while i < len(patch_lines):
+            line = patch_lines[i]
+            if line.lstrip().startswith("@@"):
+                if line.strip() == "@@":
+                    # Handle minimal hunk header without line numbers.
+                    orig_start = 1
+                else:
+                    m = hunk_header_re.match(line.strip())
+                    if not m:
+                        print("Invalid hunk header:", line)
+                        return False
+                    orig_start = int(m.group(1)) if m.group(1) is not None else 1
+                hunk_start_index = orig_start - 1  # diff headers are 1-indexed
+                if hunk_start_index > len(original_lines):
+                    print("Hunk start index beyond file length")
+                    return False
+                new_lines.extend(original_lines[current_index:hunk_start_index])
+                current_index = hunk_start_index
+                i += 1
+                # Process the hunk lines until the next hunk header.
+                while i < len(patch_lines) and not patch_lines[i].startswith("@@"):
+                    pline = patch_lines[i]
+                    if pline.startswith(" "):
+                        # Context line must match exactly.
+                        expected = pline[1:]
+                        if current_index >= len(original_lines):
+                            print("Context line expected but file ended")
+                            return False
+                        orig_line = original_lines[current_index].rstrip("\n")
+                        if orig_line != expected:
+                            print("Context line mismatch. Expected:", expected, "Got:", orig_line)
+                            return False
+                        new_lines.append(original_lines[current_index])
+                        current_index += 1
+                    elif pline.startswith("-"):
+                        # Removal line: verify and skip from original.
+                        expected = pline[1:]
+                        if current_index >= len(original_lines):
+                            print("Removal line expected but file ended")
+                            return False
+                        orig_line = original_lines[current_index].rstrip("\n")
+                        if orig_line != expected:
+                            print("Removal line mismatch. Expected:", expected, "Got:", orig_line)
+                            return False
+                        current_index += 1
+                    elif pline.startswith("+"):
+                        # Addition line: add to new_lines.
+                        new_lines.append(pline[1:] + "\n")
+                    else:
+                        print("Unexpected line in hunk:", pline)
+                        return False
+                    i += 1
+            else:
+                # Skip non-hunk header lines.
+                i += 1
+
+        # Append any remaining lines from the original file.
+        new_lines.extend(original_lines[current_index:])
+        # Ensure parent directories exist before writing the file.
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        # Write the new content back to the file.
+        file_path.write_text("".join(new_lines), encoding="utf8")
+        return True
+
+    # Parse the diff into per-file patches.
+    file_patches = parse_diff_per_file(diff_text)
+    if not file_patches:
+        print("No file patches found in diff.")
+        return False
+
+    # Record original file hashes.
+    original_hashes = {}
+    for file_path, _ in file_patches:
+        target_file = Path(project_dir) / file_path
+        if target_file.exists():
+            original_hashes[file_path] = file_hash(target_file)
+        else:
+            original_hashes[file_path] = None
+
+    any_change = False
+    # Process each file patch.
+    for file_path, patch in file_patches:
+        target_file = Path(project_dir) / file_path
+        if "+++ /dev/null" in patch:
+            # Deletion patch: delete the file if it exists.
+            if target_file.exists():
+                target_file.unlink()
+                if not target_file.exists():
+                    any_change = True
+                else:
+                    print(f"Failed to delete file: {target_file}")
+                    return False
+        else:
+            # Modification or new file creation.
+            success = apply_patch_to_file(target_file, patch)
+            if not success:
+                print(f"Failed to apply patch to file: {target_file}")
+                return False
+
+    # Verify that at least one file was changed by comparing hashes.
+    for file_path, patch in file_patches:
+        target_file = Path(project_dir) / file_path
+        if "+++ /dev/null" in patch:
+            if not target_file.exists():
+                any_change = True
+            else:
+                print(f"Expected deletion but file still exists: {target_file}")
+                return False
+        else:
+            old_hash = original_hashes.get(file_path)
+            if target_file.exists():
+                new_hash = file_hash(target_file)
+                if old_hash != new_hash:
+                    any_change = True
+                else:
+                    print(f"No change detected in file: {target_file}")
+            else:
+                print(f"Expected modification or creation but file is missing: {target_file}")
+                return False
+
+    if not any_change:
+        print("Patch applied but no file modifications detected.")
+        return False
+    return True
+
+def parse_diff_per_file(diff_text):
+    """Parse unified diff text into individual file patches.
+
+    Splits a multi-file diff into per-file entries for processing. Handles:
+    - File creations (+++ /dev/null)
+    - File deletions (--- /dev/null)
+    - Standard modifications
+
+    Args:
+        diff_text: Unified diff string as generated by `git diff`
+
+    Returns:
+        List of tuples (file_path, patch) where:
+        - file_path: Relative path to modified file
+        - patch: Full diff fragment for this file
+
+    Note:
+        Uses 'b/' prefix detection from git diffs to determine target paths
+    """
+    header_re = re.compile(r'^(?:diff --git\s+)?(a/[^ ]+)\s+(b/[^ ]+)\s*$', re.MULTILINE)
+    lines = diff_text.splitlines()
+
+    # Check if any header line exists.
+    if not any(header_re.match(line) for line in lines):
+        # Fallback strategy: detect file headers starting with '--- a/' or '-- a/'
+        diffs = []
+        current_lines = []
+        current_file = None
+        deletion_mode = False
+        header_line_re = re.compile(r'^-{2,3}\s+a/(.+)$')
+
+        for line in lines:
+            if header_line_re.match(line):
+                if current_file is not None and current_lines:
+                    if deletion_mode and not any(l.startswith("+++ /dev/null") for l in current_lines):
+                        current_lines.append("+++ /dev/null")
+                    diffs.append((current_file, "\n".join(current_lines)))
+                current_lines = [line]
+                deletion_mode = False
+                file_from = header_line_re.match(line).group(1).strip()
+                current_file = file_from
+            else:
+                current_lines.append(line)
+                if "deleted file mode" in line:
+                    deletion_mode = True
+                if line.startswith("+++ "):
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        file_to = parts[1].strip()
+                        if file_to != "/dev/null":
+                            current_file = file_to[2:] if (file_to.startswith("a/") or file_to.startswith("b/")) else file_to
+        if current_file is not None and current_lines:
+            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
+    else:
+        # Use header-based strategy.
+        diffs = []
+        current_lines = []
+        current_file = None
+        deletion_mode = False
+        for line in lines:
+            m = header_re.match(line)
+            if m:
+                if current_file is not None and current_lines:
+                    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)))
+                current_lines = [line]
+                deletion_mode = False
+                file_from = m.group(1)  # e.g. "a/index.html"
+                file_to = m.group(2)    # e.g. "b/index.html"
+                current_file = file_to[2:] if file_to.startswith("b/") else file_to
+            else:
+                current_lines.append(line)
+                if "deleted file mode" in line:
+                    deletion_mode = True
+                if line.startswith("+++ "):
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        file_to = parts[1].strip()
+                        if file_to != "/dev/null":
+                            current_file = file_to[2:] if (file_to.startswith("a/") or file_to.startswith("b/")) else file_to
+        if current_file is not None and current_lines:
+            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
+
+

{gptdiff-0.1.22 → gptdiff-0.1.24}/gptdiff/gptdiff.py

@@ -3,29 +3,38 @@ from pathlib import Path
 import subprocess
 import hashlib
 import re
-
+import time
+import os
+import json
+import subprocess
+import sys
+import fnmatch
+import argparse
+import pkgutil
+import contextvars
+from pkgutil import get_data
+import threading
 
 import openai
 from openai import OpenAI
-
 import tiktoken
 import time
-
 import os
 import json
 import subprocess
-from pathlib import Path
 import sys
 import fnmatch
 import argparse
 import pkgutil
-import re
 import contextvars
-from ai_agent_toolbox import MarkdownParser, MarkdownPromptFormatter, Toolbox, FlatXMLParser, FlatXMLPromptFormatter
-import threading
 from pkgutil import get_data
+import threading
+from ai_agent_toolbox import MarkdownParser, MarkdownPromptFormatter, Toolbox, FlatXMLParser, FlatXMLPromptFormatter
+from .applydiff import apply_diff, parse_diff_per_file
 
+VERBOSE = False
 diff_context = contextvars.ContextVar('diffcontent', default="")
+
 def create_diff_toolbox():
     toolbox = Toolbox()
     
@@ -97,7 +106,9 @@ def color_code_diff(diff_text: str) -> str:
 
 def load_gitignore_patterns(gitignore_path):
     with open(gitignore_path, 'r') as f:
-        patterns = [line.strip() for line in f if line.strip() and not line.startswith('#')]
+        patterns = [
+            line.strip() for line in f if line.strip() and not line.startswith('#')
+        ]
     return patterns
 
 def is_ignored(filepath, gitignore_patterns):
@@ -165,7 +176,7 @@ def load_project_files(project_dir, cwd):
         Prints skipped files to stdout for visibility
     """
     ignore_paths = [Path(cwd) / ".gitignore", Path(cwd) / ".gptignore"]
-    gitignore_patterns = [".gitignore", "diff.patch", "prompt.txt", ".gptignore", "*.pdf", "*.docx", ".git", "*.orig", "*.rej", "*.diff"]
+    gitignore_patterns = [".gitignore", "diff.patch", "prompt.txt", ".*", ".gptignore", "*.pdf", "*.docx", ".git", "*.orig", "*.rej", "*.diff"]
 
     for p in ignore_paths:
         if p.exists():
@@ -175,14 +186,15 @@ def load_project_files(project_dir, cwd):
     project_files = []
     for file in list_files_and_dirs(project_dir, gitignore_patterns):
         if os.path.isfile(file):
-                try:
-                    with open(file, 'r') as f:
-                        content = f.read()
+            try:
+                with open(file, 'r') as f:
+                    content = f.read()
+                if VERBOSE:
                     print(file)
-                    project_files.append((file, content))
-                except UnicodeDecodeError:
-                    print(f"Skipping file {file} due to UnicodeDecodeError")
-                    continue
+                project_files.append((file, content))
+            except UnicodeDecodeError:
+                print(f"Skipping file {file} due to UnicodeDecodeError")
+                continue
 
     print("")
     return project_files
@@ -194,37 +206,54 @@ def load_prepend_file(file):
 # Function to call GPT-4 API and calculate the cost
 def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperature=0.7, max_tokens=30000, api_key=None, base_url=None):
     enc = tiktoken.get_encoding("o200k_base")
+    
+    # Use colors in print statements
+    red = "\033[91m"
+    green = "\033[92m"
+    reset = "\033[0m"
     start_time = time.time()
 
     parser = MarkdownParser()
     formatter = MarkdownPromptFormatter()
     toolbox = create_diff_toolbox()
     tool_prompt = formatter.usage_prompt(toolbox)
-    system_prompt += "\n"+tool_prompt
+    system_prompt += "\n" + tool_prompt
 
     if 'gemini' in model:
-        user_prompt = system_prompt+"\n"+user_prompt
+        user_prompt = system_prompt + "\n" + user_prompt
 
     messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": user_prompt + "\n"+files_content},
+        {"role": "system", "content": f"{green}{system_prompt}{reset}"},
+        {"role": "user", "content": user_prompt + "\n" + files_content},
     ]
-    print("Using", model)
-    print("SYSTEM PROMPT")
-    print(system_prompt)
-    print("USER PROMPT")
-    print(user_prompt, "+", len(enc.encode(files_content)), "tokens of file content")
+    if VERBOSE:
+        print(f"{green}Using {model}{reset}")
+        print(f"{green}SYSTEM PROMPT{reset}")
+        print(system_prompt)
+        print(f"{green}USER PROMPT{reset}")
+        print(user_prompt, "+", len(enc.encode(files_content)), "tokens of file content")
+    else:
+        print("Generating diff...")
 
-    if api_key is None:
+    if not api_key:
         api_key = os.getenv('GPTDIFF_LLM_API_KEY')
-    if base_url is None:
+    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,
         messages=messages,
         max_tokens=max_tokens,
         temperature=temperature)
 
+    if VERBOSE:
+        print("RESPONSE RAW-------------")
+        print(response.choices[0].message.content.strip())
+        print("/RESPONSE RAW-------------")
+    else:
+        print("Diff generated.")
+
     prompt_tokens = response.usage.prompt_tokens
     completion_tokens = response.usage.completion_tokens
     total_tokens = response.usage.total_tokens
@@ -361,172 +390,6 @@ def smartapply(diff_text, files, model=None, api_key=None, base_url=None):
 
     return files
 
-def apply_diff(project_dir, diff_text):
-    """
-    Applies a unified diff (as generated by git diff) to the files in project_dir
-    using pure Python (without calling the external 'patch' command).
-
-    Handles file modifications, new file creation, and file deletions.
-
-    Returns:
-        True if at least one file was modified (or deleted/created) as a result of the patch,
-        False otherwise.
-    """
-    from pathlib import Path
-    import re, hashlib
-
-    def file_hash(filepath):
-        h = hashlib.sha256()
-        with open(filepath, "rb") as f:
-            h.update(f.read())
-        return h.hexdigest()
-
-    def apply_patch_to_file(file_path, patch):
-        """
-        Applies a unified diff patch (for a single file) to file_path.
-
-        Returns True if the patch was applied successfully, False otherwise.
-        """
-        # Read the original file lines; if the file doesn't exist, treat it as empty.
-        if file_path.exists():
-            original_lines = file_path.read_text(encoding="utf8").splitlines(keepends=True)
-        else:
-            original_lines = []
-        new_lines = []
-        current_index = 0
-
-        patch_lines = patch.splitlines()
-        # Regex for a hunk header, e.g., @@ -3,7 +3,6 @@
-        hunk_header_re = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
-        i = 0
-        while i < len(patch_lines):
-            line = patch_lines[i]
-            if line.startswith("@@"):
-                m = hunk_header_re.match(line)
-                if not m:
-                    print("Invalid hunk header:", line)
-                    return False
-                orig_start = int(m.group(1))
-                # orig_len = int(m.group(2)) if m.group(2) else 1  # not used explicitly
-                # new_start = int(m.group(3))
-                # new_len = int(m.group(4)) if m.group(4) else 1
-
-                # Copy unchanged lines before the hunk.
-                hunk_start_index = orig_start - 1  # diff headers are 1-indexed
-                if hunk_start_index > len(original_lines):
-                    print("Hunk start index beyond file length")
-                    return False
-                new_lines.extend(original_lines[current_index:hunk_start_index])
-                current_index = hunk_start_index
-
-                i += 1
-                # Process the hunk lines until the next hunk header.
-                while i < len(patch_lines) and not patch_lines[i].startswith("@@"):
-                    pline = patch_lines[i]
-                    if pline.startswith(" "):
-                        # Context line must match exactly.
-                        expected = pline[1:]
-                        if current_index >= len(original_lines):
-                            print("Context line expected but file ended")
-                            return False
-                        orig_line = original_lines[current_index].rstrip("\n")
-                        if orig_line != expected:
-                            print("Context line mismatch. Expected:", expected, "Got:", orig_line)
-                            return False
-                        new_lines.append(original_lines[current_index])
-                        current_index += 1
-                    elif pline.startswith("-"):
-                        # Removal line: verify and skip from original.
-                        expected = pline[1:]
-                        if current_index >= len(original_lines):
-                            print("Removal line expected but file ended")
-                            return False
-                        orig_line = original_lines[current_index].rstrip("\n")
-                        if orig_line != expected:
-                            print("Removal line mismatch. Expected:", expected, "Got:", orig_line)
-                            return False
-                        current_index += 1
-                    elif pline.startswith("+"):
-                        # Addition line: add to new_lines.
-                        new_lines.append(pline[1:] + "\n")
-                    else:
-                        print("Unexpected line in hunk:", pline)
-                        return False
-                    i += 1
-            else:
-                # Skip non-hunk header lines.
-                i += 1
-
-        # Append any remaining lines from the original file.
-        new_lines.extend(original_lines[current_index:])
-        # Ensure parent directories exist before writing the file.
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-        # Write the new content back to the file.
-        file_path.write_text("".join(new_lines), encoding="utf8")
-        return True
-
-    # Parse the diff into per-file patches.
-    file_patches = parse_diff_per_file(diff_text)
-    if not file_patches:
-        print("No file patches found in diff.")
-        return False
-
-    # Record original file hashes.
-    original_hashes = {}
-    for file_path, _ in file_patches:
-        target_file = Path(project_dir) / file_path
-        if target_file.exists():
-            original_hashes[file_path] = file_hash(target_file)
-        else:
-            original_hashes[file_path] = None
-
-    any_change = False
-    # Process each file patch.
-    for file_path, patch in file_patches:
-        target_file = Path(project_dir) / file_path
-        if "+++ /dev/null" in patch:
-            # Deletion patch: delete the file if it exists.
-            if target_file.exists():
-                target_file.unlink()
-                if not target_file.exists():
-                    any_change = True
-                else:
-                    print(f"Failed to delete file: {target_file}")
-                    return False
-        else:
-            # Modification or new file creation.
-            success = apply_patch_to_file(target_file, patch)
-            if not success:
-                print(f"Failed to apply patch to file: {target_file}")
-                return False
-
-    # Verify that at least one file was changed by comparing hashes.
-    for file_path, patch in file_patches:
-        target_file = Path(project_dir) / file_path
-        if "+++ /dev/null" in patch:
-            if not target_file.exists():
-                any_change = True
-            else:
-                print(f"Expected deletion but file still exists: {target_file}")
-                return False
-        else:
-            old_hash = original_hashes.get(file_path)
-            if target_file.exists():
-                new_hash = file_hash(target_file)
-                if old_hash != new_hash:
-                    any_change = True
-                else:
-                    print(f"No change detected in file: {target_file}")
-            else:
-                print(f"Expected modification or creation but file is missing: {target_file}")
-                return False
-
-    if not any_change:
-        print("Patch applied but no file modifications detected.")
-        return False
-    return True
-
-
 def parse_arguments():
     parser = argparse.ArgumentParser(description='Generate and optionally apply git diffs using GPT-4.')
     parser.add_argument('prompt', type=str, help='Prompt that runs on the codebase.')
@@ -542,9 +405,8 @@ def parse_arguments():
     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('--verbose', action='store_true', help='Enable verbose output with detailed information')
     return parser.parse_args()
 
 def absolute_to_relative(absolute_path):
@@ -552,95 +414,8 @@ def absolute_to_relative(absolute_path):
     relative_path = os.path.relpath(absolute_path, cwd)
     return relative_path
 
-def parse_diff_per_file(diff_text):
-    """Parse unified diff text into individual file patches.
-
-    Splits a multi-file diff into per-file entries for processing. Handles:
-    - File creations (+++ /dev/null)
-    - File deletions (--- /dev/null)
-    - Standard modifications
-
-    Args:
-        diff_text: Unified diff string as generated by `git diff`
-
-    Returns:
-        List of tuples (file_path, patch) where:
-        - file_path: Relative path to modified file
-        - patch: Full diff fragment for this file
-
-    Note:
-        Uses 'b/' prefix detection from git diffs to determine target paths
-    """
-    header_re = re.compile(r'^(?:diff --git\s+)?(a/[^ ]+)\s+(b/[^ ]+)\s*$', re.MULTILINE)
-    lines = diff_text.splitlines()
-
-    # Check if any header line exists.
-    if not any(header_re.match(line) for line in lines):
-        # Fallback strategy: detect file headers starting with '--- a/' or '-- a/'
-        diffs = []
-        current_lines = []
-        current_file = None
-        deletion_mode = False
-        header_line_re = re.compile(r'^-{2,3}\s+a/(.+)$')
-
-        for line in lines:
-            if header_line_re.match(line):
-                if current_file is not None and current_lines:
-                    if deletion_mode and not any(l.startswith("+++ /dev/null") for l in current_lines):
-                        current_lines.append("+++ /dev/null")
-                    diffs.append((current_file, "\n".join(current_lines)))
-                current_lines = [line]
-                deletion_mode = False
-                file_from = header_line_re.match(line).group(1).strip()
-                current_file = file_from
-            else:
-                current_lines.append(line)
-                if "deleted file mode" in line:
-                    deletion_mode = True
-                if line.startswith("+++ "):
-                    parts = line.split()
-                    if len(parts) >= 2:
-                        file_to = parts[1].strip()
-                        if file_to != "/dev/null":
-                            current_file = file_to[2:] if (file_to.startswith("a/") or file_to.startswith("b/")) else file_to
-        if current_file is not None and current_lines:
-            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
-    else:
-        # Use header-based strategy.
-        diffs = []
-        current_lines = []
-        current_file = None
-        deletion_mode = False
-        for line in lines:
-            m = header_re.match(line)
-            if m:
-                if current_file is not None and current_lines:
-                    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)))
-                current_lines = [line]
-                deletion_mode = False
-                file_from = m.group(1)  # e.g. "a/index.html"
-                file_to = m.group(2)    # e.g. "b/index.html"
-                current_file = file_to[2:] if file_to.startswith("b/") else file_to
-            else:
-                current_lines.append(line)
-                if "deleted file mode" in line:
-                    deletion_mode = True
-                if line.startswith("+++ "):
-                    parts = line.split()
-                    if len(parts) >= 2:
-                        file_to = parts[1].strip()
-                        if file_to != "/dev/null":
-                            current_file = file_to[2:] if (file_to.startswith("a/") or file_to.startswith("b/")) else file_to
-        if current_file is not None and current_lines:
-            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
+def colorize_warning_warning(message):
+    return f"\033[91m\033[1m{message}\033[0m"
 
 def call_llm_for_apply_with_think_tool_available(file_path, original_content, file_diff, model, api_key=None, base_url=None, extra_prompt=None, max_tokens=30000):
     parser = FlatXMLParser("think")
@@ -720,9 +495,9 @@ Diff to apply:
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": user_prompt},
     ]
-    if api_key is None:
+    if not api_key:
         api_key = os.getenv('GPTDIFF_LLM_API_KEY')
-    if base_url is None:
+    if not base_url:
         base_url = os.getenv('GPTDIFF_LLM_BASE_URL', "https://nano-gpt.com/api/v1/")
     client = OpenAI(api_key=api_key, base_url=base_url)
     start_time = time.time()
@@ -734,8 +509,11 @@ Diff to apply:
     elapsed = time.time() - start_time
     minutes, seconds = divmod(int(elapsed), 60)
     time_str = f"{minutes}m {seconds}s" if minutes else f"{seconds}s"
-    print(f"Smartapply time: {time_str}")
-    print("-" * 40)
+    if VERBOSE:
+        print(f"Smartapply time: {time_str}")
+        print("-" * 40)
+    else:
+        print(f"Smartapply completed in {time_str}")
     return full_response
 
 def build_environment_from_filelist(file_list, cwd):
@@ -763,7 +541,7 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
     parsed_diffs = parse_diff_per_file(diff_text)
     print("Found", len(parsed_diffs), "files in diff, processing smart apply concurrently:")
     if len(parsed_diffs) == 0:
-        print("\033[1;33mThere were no entries in this diff. The LLM may have returned something invalid.\033[0m")
+        print(colorize_warning_warning("There were no entries in this diff. The LLM may have returned something invalid."))
         if args.beep:
             print("\a")
         return
@@ -771,13 +549,14 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
 
     def process_file(file_path, file_diff):
         full_path = Path(project_dir) / file_path
-        print(f"Processing file: {file_path}")
+        if VERBOSE:
+            print(f"Processing file: {file_path}")
         if '+++ /dev/null' in file_diff:
             if full_path.exists():
                 full_path.unlink()
                 print(f"\033[1;32mDeleted file {file_path}.\033[0m")
             else:
-                print(f"\033[1;33mFile {file_path} not found - skipping deletion\033[0m")
+                print(colorize_warning_warning(f"File {file_path} not found - skipping deletion"))
             return
 
         try:
@@ -862,11 +641,13 @@ def save_files(files_dict, target_directory):
         print(f"Saved: {full_path}")
 
 def main():
+    global VERBOSE
     # Adding color support for Windows CMD
     if os.name == 'nt':
         os.system('color')
 
     args = parse_arguments()
+    VERBOSE = args.verbose
 
     # openai.api_base = "https://nano-gpt.com/api/v1/"
     if len(sys.argv) < 2:
@@ -916,9 +697,8 @@ def main():
 
     files_content = ""
     for file, content in project_files:
-        print(f"Including {len(enc.encode(content)):5d} tokens", absolute_to_relative(file))
-
-        # Prepare the prompt for GPT-4
+        if VERBOSE:
+            print(f"Including {len(enc.encode(content)):5d} tokens", absolute_to_relative(file))
         files_content += f"File: {absolute_to_relative(file)}\nContent:\n{content}\n"
 
     full_prompt = f"{system_prompt}\n\n{user_prompt}\n\n{files_content}"

{gptdiff-0.1.22 → gptdiff-0.1.24}/gptdiff/gptpatch.py

@@ -13,8 +13,7 @@ This tool uses the same patch-application logic as gptdiff.
 import sys
 import argparse
 from pathlib import Path
-from gptdiff.gptdiff import apply_diff
-
+from gptdiff.gptdiff import apply_diff, smart_apply_patch
 
 def parse_arguments():
     parser = argparse.ArgumentParser(
@@ -50,6 +49,7 @@ def parse_arguments():
         default=30000,
         help="Maximum tokens to use for LLM responses"
     )
+    parser.add_argument('--dumb', action='store_true', default=False, help='Attempt dumb apply before trying smart apply')
     return parser.parse_args()
 
 def main():
@@ -64,12 +64,14 @@ def main():
         diff_text = diff_path.read_text(encoding="utf8")
 
     project_dir = args.project_dir
-    success = apply_diff(project_dir, diff_text)
-    if success:
-        print("✅ Diff applied successfully.")
+    if args.dumb:
+        success = apply_diff(project_dir, diff_text)
+        if success:
+            print("✅ Diff applied successfully.")
+        else:
+            print("❌ Failed to apply diff using git apply. Attempting smart apply.")
+            smart_apply_patch(project_dir, diff_text, "", args)
     else:
-        print("❌ Failed to apply diff using git apply. Attempting smart apply.")
-        from gptdiff.gptdiff import smart_apply_patch
         smart_apply_patch(project_dir, diff_text, "", args)
         
 if __name__ == "__main__":

{gptdiff-0.1.22 → gptdiff-0.1.24}/gptdiff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.22
+Version: 0.1.24
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License

{gptdiff-0.1.22 → gptdiff-0.1.24}/gptdiff.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE.txt
 README.md
 setup.py
 gptdiff/__init__.py
+gptdiff/applydiff.py
 gptdiff/gptdiff.py
 gptdiff/gptpatch.py
 gptdiff.egg-info/PKG-INFO

{gptdiff-0.1.22 → gptdiff-0.1.24}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='gptdiff',
-    version='0.1.22',
+    version='0.1.24',
     description='A tool to generate and apply git diffs using LLMs',
     author='255labs',
     packages=find_packages(),  # Use find_packages() to automatically discover packages

gptdiff-0.1.24/tests/test_applydiff.py

@@ -0,0 +1,143 @@
+import os
+from pathlib import Path
+
+import pytest
+
+from gptdiff.gptdiff import apply_diff
+
+
+@pytest.fixture
+def tmp_project_dir_with_file(tmp_path):
+    """
+    Create a temporary project directory with a dummy file to patch.
+    """
+    project_dir = tmp_path / "project"
+    project_dir.mkdir()
+    file = project_dir / "example.txt"
+    file.write_text("original content\n")
+    return project_dir
+
+
+def test_apply_diff_success(tmp_project_dir_with_file):
+    """
+    Test that apply_diff successfully applies a valid diff.
+    The diff changes 'original content' to 'modified content'.
+    """
+    diff_text = (
+        "diff --git a/example.txt b/example.txt\n"
+        "--- a/example.txt\n"
+        "+++ a/example.txt\n"
+        "@@ -1 +1 @@\n"
+        "-original content\n"
+        "+modified content\n"
+    )
+    result = apply_diff(str(tmp_project_dir_with_file), diff_text)
+    assert result is True, "apply_diff should return True for a successful patch"
+
+    file_path = tmp_project_dir_with_file / "example.txt"
+    content = file_path.read_text()
+    assert "modified content" in content, "File content should be updated to 'modified content'"
+
+
+def test_apply_diff_failure(tmp_project_dir_with_file):
+    """
+    Test that apply_diff fails when provided with an incorrect hunk header.
+    The diff references a non-existent line, so the patch should not apply.
+    """
+    diff_text = (
+        "diff --git a/example.txt b/example.txt\n"
+        "--- a/example.txt\n"
+        "+++ a/example.txt\n"
+        "@@ -2,1 +2,1 @@\n"
+        "-original content\n"
+        "+modified content\n"
+    )
+    result = apply_diff(str(tmp_project_dir_with_file), diff_text)
+    assert result is False, "apply_diff should return False when the diff fails to apply"
+
+    file_path = tmp_project_dir_with_file / "example.txt"
+    content = file_path.read_text()
+    assert "original content" in content, "File content should remain unchanged on failure"
+
+
+def test_apply_diff_file_deletion(tmp_project_dir_with_file):
+    """
+    Test that apply_diff can successfully delete a file.
+    The diff marks 'example.txt' for deletion.
+    """
+    diff_text = (
+        "diff --git a/example.txt b/example.txt\n"
+        "deleted file mode 100644\n"
+        "--- a/example.txt\n"
+        "+++ /dev/null\n"
+        "@@ -1,1 +0,0 @@\n"
+        "-original content\n"
+    )
+    result = apply_diff(str(tmp_project_dir_with_file), diff_text)
+    assert result is True, "apply_diff should return True for a successful file deletion"
+
+    file_path = tmp_project_dir_with_file / "example.txt"
+    assert not file_path.exists(), "File should be deleted after applying the diff"
+
+
+@pytest.fixture
+def tmp_project_dir_empty(tmp_path):
+    project_dir = tmp_path / "project"
+    project_dir.mkdir()
+    return project_dir
+
+
+def test_minimal_new_file_diff(tmp_project_dir_empty):
+    diff_text = (
+        "diff --git a/new.txt b/new.txt\n"
+        "new file mode 100644\n"
+        "--- /dev/null\n"
+        "+++ b/new.txt\n"
+        "@@\n"
+        "+hello world\n"
+    )
+    result = apply_diff(str(tmp_project_dir_empty), diff_text)
+    assert result is True
+    new_file = tmp_project_dir_empty / "new.txt"
+    assert new_file.exists()
+    assert new_file.read_text() == "hello world\n"
+
+import pytest
+from pathlib import Path
+from gptdiff.gptdiff import apply_diff
+
+@pytest.fixture
+def tmp_project_dir_empty(tmp_path):
+    project_dir = tmp_path / "project"
+    project_dir.mkdir()
+    return project_dir
+
+def test_new_file_creation_minimal_header_failure(tmp_project_dir_empty):
+    """
+    Test that a minimal diff for new file creation (with a hunk header that lacks line numbers)
+    creates the file with the expected content.
+
+    Diff text:
+        --- /dev/null
+        +++ b/test_feature_1739491796.py
+        @@
+        +import pytest
+        +
+
+    Expected result: a new file "test_feature_1739491796.py" containing "import pytest\n"
+    """
+    diff_text = (
+        "--- /dev/null\n"
+        "+++ b/test_feature_1739491796.py\n"
+        "@@\n"
+        "+import pytest\n"
+        "+\n"
+    )
+    result = apply_diff(str(tmp_project_dir_empty), diff_text)
+    assert result is True, "apply_diff should return True for a successful new file creation"
+    new_file = tmp_project_dir_empty / "test_feature_1739491796.py"
+    assert new_file.exists(), "New file should be created"
+    expected_content = "import pytest\n"
+    content = new_file.read_text()
+    assert content.strip() == expected_content.strip(), f"Expected file content:\n{expected_content}\nGot:\n{content}"
+

{gptdiff-0.1.22 → gptdiff-0.1.24}/tests/test_smartapply.py

@@ -122,7 +122,7 @@ def test_smartapply_modify_nonexistent_file():
         result = smartapply(diff_text, original_files)
         assert "newfile.py" in result
 
-def test_smartapply_multi_file_modification(mocker):
+def test_smartapply_multi_file_modification(monkeypatch):
     """Test smartapply handles multi-file modifications through LLM integration.
     
     Verifies:
@@ -167,8 +167,7 @@ diff --git a/file2.py b/file2.py
             return "def func2():\n    print('New func2')"
         return original_content
 
-    mocker.patch('gptdiff.gptdiff.call_llm_for_apply', side_effect=mock_call_llm)
-
+    monkeypatch.setattr('gptdiff.gptdiff.call_llm_for_apply', mock_call_llm)
     updated_files = smartapply(diff_text, original_files)
     
     # Verify both target files modified
@@ -184,7 +183,7 @@ diff --git a/file2.py b/file2.py
     assert updated_files["unrelated.py"] == "def unrelated():\n    pass"
 
 
-def test_smartapply_complex_single_hunk(mocker):
+def test_smartapply_complex_single_hunk(monkeypatch):
     """Test complex single hunk with multiple change types
     
     Validates proper handling of:
@@ -235,7 +234,7 @@ def test_smartapply_complex_single_hunk(mocker):
         "        results.append(x ** 2)\n"
         "    return results"
     )
-    mocker.patch('gptdiff.gptdiff.call_llm_for_apply', return_value=expected_content)
+    monkeypatch.setattr('gptdiff.gptdiff.call_llm_for_apply', lambda *args, **kwargs: expected_content)
 
     updated_files = smartapply(diff_text, original_files)
     

gptdiff-0.1.22/tests/test_applydiff.py

@@ -1,80 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-
-from gptdiff.gptdiff import apply_diff
-
-
-@pytest.fixture
-def tmp_project_dir(tmp_path):
-    """
-    Create a temporary project directory with a dummy file to patch.
-    """
-    project_dir = tmp_path / "project"
-    project_dir.mkdir()
-    file = project_dir / "example.txt"
-    file.write_text("original content\n")
-    return project_dir
-
-
-def test_apply_diff_success(tmp_project_dir):
-    """
-    Test that apply_diff successfully applies a valid diff.
-    The diff changes 'original content' to 'modified content'.
-    """
-    diff_text = (
-        "diff --git a/example.txt b/example.txt\n"
-        "--- a/example.txt\n"
-        "+++ b/example.txt\n"
-        "@@ -1 +1 @@\n"
-        "-original content\n"
-        "+modified content\n"
-    )
-    result = apply_diff(str(tmp_project_dir), diff_text)
-    assert result is True, "apply_diff should return True for a successful patch"
-
-    file_path = tmp_project_dir / "example.txt"
-    content = file_path.read_text()
-    assert "modified content" in content, "File content should be updated to 'modified content'"
-
-
-def test_apply_diff_failure(tmp_project_dir):
-    """
-    Test that apply_diff fails when provided with an incorrect hunk header.
-    The diff references a non-existent line, so the patch should not apply.
-    """
-    diff_text = (
-        "diff --git a/example.txt b/example.txt\n"
-        "--- a/example.txt\n"
-        "+++ a/example.txt\n"
-        "@@ -2,1 +2,1 @@\n"
-        "-original content\n"
-        "+modified content\n"
-    )
-    result = apply_diff(str(tmp_project_dir), diff_text)
-    assert result is False, "apply_diff should return False when the diff fails to apply"
-
-    file_path = tmp_project_dir / "example.txt"
-    content = file_path.read_text()
-    assert "original content" in content, "File content should remain unchanged on failure"
-
-
-def test_apply_diff_file_deletion(tmp_project_dir):
-    """
-    Test that apply_diff can successfully delete a file.
-    The diff marks 'example.txt' for deletion.
-    """
-    diff_text = (
-        "diff --git a/example.txt b/example.txt\n"
-        "deleted file mode 100644\n"
-        "--- a/example.txt\n"
-        "+++ /dev/null\n"
-        "@@ -1,1 +0,0 @@\n"
-        "-original content\n"
-    )
-    result = apply_diff(str(tmp_project_dir), diff_text)
-    assert result is True, "apply_diff should return True for a successful file deletion"
-
-    file_path = tmp_project_dir / "example.txt"
-    assert not file_path.exists(), "File should be deleted after applying the diff"