gptdiff 0.1.22__py3-none-any.whl → 0.1.27__py3-none-any.whl

gptdiff/applydiff.py

@@ -0,0 +1,265 @@
+"""
+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
+        This doesn't work all the time and needs to be revised with stronger models
+    """
+    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/gptdiff.py

@@ -1,31 +1,42 @@
 #!/usr/bin/env python3
 from pathlib import Path
+from urllib.parse import urlparse
 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
+from threading import Lock
 
 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 +108,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 +178,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 +188,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
@@ -191,40 +205,73 @@ def load_prepend_file(file):
     with open(file, 'r') as f:
         return f.read()
 
-# Function to call GPT-4 API and calculate the cost
+def domain_for_url(base_url):
+    parsed = urlparse(base_url)
+    if parsed.netloc:
+        if parsed.username:
+            domain = parsed.hostname
+            if parsed.port:
+                domain += f":{parsed.port}"
+        else:
+            domain = parsed.netloc
+    else:
+        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):
     enc = tiktoken.get_encoding("o200k_base")
+    
+    # Use colors in print statements
+    red = "\033[91m"
+    green = "\033[92m"
+    blue = "\033[94m"
+    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
 
+    input_content = system_prompt + "\n" + user_prompt + "\n" + files_content
+    token_count = len(enc.encode(input_content))
     messages = [
         {"role": "system", "content": system_prompt},
-        {"role": "user", "content": user_prompt + "\n"+files_content},
+        {"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 api_key is None:
+    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(f"Generating diff using model '{green}{model}{reset}' from '{blue}{domain_for_url(base_url)}{reset}' with {token_count} input tokens...")
+
+    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("Debug: Raw LLM Response\n---")
+        print(response.choices[0].message.content.strip())
+        print("---")
+    else:
+        print("Diff generated.")
+
     prompt_tokens = response.usage.prompt_tokens
     completion_tokens = response.usage.completion_tokens
     total_tokens = response.usage.total_tokens
@@ -236,9 +283,6 @@ def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperat
     print("-" * 40)
 
     # Now, these rates are updated to per million tokens
-    cost_per_million_prompt_tokens = 30
-    cost_per_million_completion_tokens = 60
-    cost = (prompt_tokens / 1_000_000 * cost_per_million_prompt_tokens) + (completion_tokens / 1_000_000 * cost_per_million_completion_tokens)
 
     full_response = response.choices[0].message.content.strip()
     full_response, reasoning = swallow_reasoning(full_response)
@@ -250,7 +294,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, cost
+    return full_response, diff_response, prompt_tokens, completion_tokens, total_tokens
 
 # New API functions
 def build_environment(files_dict):
@@ -361,172 +405,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 +420,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 +429,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 +510,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 +524,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):
@@ -760,31 +553,44 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
     Attempt to apply a diff via smartapply: process each file concurrently using the LLM.
     """
     from pathlib import Path
+    start_time = time.time()
     parsed_diffs = parse_diff_per_file(diff_text)
     print("Found", len(parsed_diffs), "files in diff, processing smart apply concurrently:")
+    green = "\033[92m"
+    red = "\033[91m"
+    blue = "\033[94m"
+    reset = "\033[0m"
+
     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
     threads = []
+    success_files = []
+    failed_files = []
+    success_lock = Lock()
 
     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:
-            original_content = full_path.read_text()
-        except (UnicodeDecodeError, IOError):
-            print(f"Skipping file {file_path} due to read error")
-            return
+        original_content = ""
+        if full_path.exists():
+            try:
+                original_content = full_path.read_text()
+            except (UnicodeDecodeError, IOError) as e:
+                print(f"Cannot read {file_path} due to {str(e)}, treating as new file")
+        else:
+            print(f"File {file_path} does not exist, treating as new file")
 
         # Use SMARTAPPLY-specific environment variables if set, otherwise fallback.
         smart_apply_model = os.getenv("GPTDIFF_SMARTAPPLY_MODEL")
@@ -807,9 +613,7 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
         else:
             base_url = os.getenv("GPTDIFF_LLM_BASE_URL", "https://nano-gpt.com/api/v1/")
 
-        print("-" * 40)
-        print("Running smartapply with", model, "on", file_path)
-        print("-" * 40)
+        print(f"Running smartapply in parallel using model '{green}{model}{reset}' from '{blue}{domain_for_url(base_url)}{reset}'...")
         try:
             updated_content = call_llm_for_apply_with_think_tool_available(
                 file_path, original_content, file_diff, model,
@@ -818,12 +622,18 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
                 max_tokens=args.max_tokens)
             if updated_content.strip() == "":
                 print("Cowardly refusing to write empty file to", file_path, "merge failed")
+                with success_lock:
+                    failed_files.append(file_path)
                 return
             full_path.parent.mkdir(parents=True, exist_ok=True)
             full_path.write_text(updated_content)
             print(f"\033[1;32mSuccessful 'smartapply' update {file_path}.\033[0m")
+            with success_lock:
+                success_files.append(file_path)
         except Exception as e:
             print(f"\033[1;31mFailed to process {file_path}: {str(e)}\033[0m")
+            with success_lock:
+                failed_files.append(file_path)
 
     for file_path, file_diff in parsed_diffs:
         thread = threading.Thread(target=process_file, args=(file_path, file_diff))
@@ -831,7 +641,17 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
         threads.append(thread)
     for thread in threads:
         thread.join()
-
+    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 successfully applied changes in {time_str}. Check the updated files to confirm.")
+    if failed_files:
+        print(f"\033[1;31mSmart apply completed in {time_str} with failures for {len(failed_files)} files:\033[0m")
+        for file in failed_files:
+            print(f"  - {file}")
+        print("Please check the errors above for details.")
+    else:
+        print(f"\033[1;32mSmart apply completed successfully in {time_str} for all {len(success_files)} files.\033[0m")
     if args.beep:
         print("\a")
 
@@ -862,11 +682,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 +738,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}"
@@ -930,9 +751,8 @@ def main():
         with open('prompt.txt', 'w') as f:
             f.write(full_prompt)
         print(f"Total tokens: {token_count:5d}")
-        print(f"\033[1;32mNot calling GPT-4.\033[0m")  # Green color for success message
+        print(f"\033[1;32mWrote full prompt to prompt.txt.\033[0m")
         print('Instead, wrote full prompt to prompt.txt. Use `xclip -selection clipboard < prompt.txt` then paste into chatgpt')
-        print(f"Total cost: ${0.0:.4f}")
         exit(0)
     else:
         # Validate API key presence before any API operations
@@ -949,7 +769,7 @@ def main():
                 print("Request canceled")
                 sys.exit(0)
         try:
-            full_text, diff_text, prompt_tokens, completion_tokens, total_tokens, cost = call_llm_for_diff(system_prompt, user_prompt, files_content, args.model, 
+            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/"),
@@ -961,35 +781,40 @@ def main():
             prompt_tokens = 0
             completion_tokens = 0
             total_tokens = 0
-            cost = 0
             print(f"Error in LLM response {e}")
 
     if(diff_text.strip() == ""):
-        print(f"\033[1;33mThere was no data in this diff. The LLM may have returned something invalid.\033[0m")
-        print("Unable to parse diff text. Full response:", full_text)
+        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")
+        print("Suggested action: Refine your prompt or check the full response below for clues.")
+        print("Full LLM response:\n---\n" + full_text + "\n---")
         if args.beep:
-            print("\a")  # Terminal bell for completion notification
+            print("\a")
         return
 
     elif args.apply:
         print("\nAttempting apply with the following diff:")
-        print("\n<diff>")
         print(color_code_diff(diff_text))
-        print("\n</diff>")
-        print("Saved to patch.diff")
-        if apply_diff(project_dir, diff_text):
-            print(f"\033[1;32mPatch applied successfully with 'git apply'.\033[0m")
+        print("\033[94m**Attempting to apply patch using basic method...**\033[0m")
+        apply_result = apply_diff(project_dir, diff_text)
+        if apply_result:
+            print(f"\033[1;32mPatch applied successfully with basic apply.\033[0m")
         else:
-            print("Apply failed, attempting smart apply.")
+            print("\033[94m**Attempting smart apply with LLM...**\033[0m")
             smart_apply_patch(project_dir, diff_text, user_prompt, args)
 
     if args.beep:
-        print("\a")  # Terminal bell for completion notification
+        print("\a")
 
-    print(f"Prompt tokens: {prompt_tokens}")
-    print(f"Completion tokens: {completion_tokens}")
-    print(f"Total tokens: {total_tokens}")
-    #print(f"Total cost: ${cost:.4f}")
+    green = "\033[92m"
+    reset = "\033[0m"
+    if VERBOSE:
+        print("API Usage Details:")
+        print(f"- Prompt tokens: {prompt_tokens}")
+        print(f"- Completion tokens: {completion_tokens}")
+        print(f"- Total tokens: {total_tokens}")
+        print(f"- Model used: {green}{args.model}{reset}")
+    else:
+        print(f"API Usage: {total_tokens} tokens, Model used: {green}{args.model}{reset}")
 
 def swallow_reasoning(full_response: str) -> (str, str):
     """

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, color_code_diff
 
 def parse_arguments():
     parser = argparse.ArgumentParser(
@@ -50,10 +49,14 @@ def parse_arguments():
         default=30000,
         help="Maximum tokens to use for LLM responses"
     )
+    parser.add_argument('--verbose', action='store_true', help='Enable verbose output with detailed information')
+    parser.add_argument('--dumb', action='store_true', default=False, help='Attempt dumb apply before trying smart apply')
     return parser.parse_args()
 
 def main():
     args = parse_arguments()
+    import gptdiff.gptdiff as gd
+    gd.VERBOSE = args.verbose
     if args.diff:
         diff_text = args.diff
     else:
@@ -64,13 +67,21 @@ 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.verbose:
+        print("\n\033[1;34mDiff to be applied:\033[0m")
+        print(color_code_diff(diff_text))
+        print("")
+
+    if args.dumb:
+        success = apply_diff(project_dir, diff_text)
+        if success:
+            print("\033[1;32m✅ Diff applied successfully.\033[0m")
+        else:
+            print("\033[1;31m❌ Failed to apply diff using git apply. Attempting smart apply.\033[0m")
+            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__":
-    main()
+    main()

{gptdiff-0.1.22.dist-info → gptdiff-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.22
+Version: 0.1.27
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License
@@ -82,13 +82,15 @@ done
 
 *Requires reasoning model*
 
-### Why GPTDiff?
+## Why Choose GPTDiff?
 
-- **Understands Your Code** - Describe changes in plain English
-- **Safe Modifications** - Keeps existing code working
-- **Auto-Fix** - `--apply` fixes mistakes in generated changes
-- **Works Instantly** - No complex setup needed
-- **Whole Project View** - Handles multiple files together
+- **Describe changes in plain English**  
+- **AI gets your whole project**  
+- **Auto-fixes conflicts**  
+- **Keeps code functional**  
+- **Fast setup, no fuss**  
+- **You approve every change**  
+- **Costs are upfront**
 
 ## Core Capabilities
 

gptdiff-0.1.27.dist-info/RECORD

@@ -0,0 +1,10 @@
+gptdiff/__init__.py,sha256=o1hrK4GFvbfKcHPlLVArz4OunE3euIicEBYaLrdDo0k,198
+gptdiff/applydiff.py,sha256=_11ITFMcigwvVptaIpEtyfLUTIy_mYPWExcXUqCBfOs,11200
+gptdiff/gptdiff.py,sha256=sG0tPku3d5agx9F8EqKTl914S5ZkRi_8oMIBhFiz-nI,33355
+gptdiff/gptpatch.py,sha256=Vqk2vliYs_BxtuTpwdS88n3A8XToh6RvrCA4N8VqOu0,2759
+gptdiff-0.1.27.dist-info/LICENSE.txt,sha256=zCJk7yUYpMjFvlipi1dKtaljF8WdZ2NASndBYYbU8BY,1228
+gptdiff-0.1.27.dist-info/METADATA,sha256=l5oPGbwCn731KeLRT3xEMElWuE1fr15c_pGLGrEzzA8,8723
+gptdiff-0.1.27.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+gptdiff-0.1.27.dist-info/entry_points.txt,sha256=0VlVNr-gc04a3SZD5_qKIBbtg_L5P2x3xlKE5ftcdkc,82
+gptdiff-0.1.27.dist-info/top_level.txt,sha256=XNkQkQGINaDndEwRxg8qToOrJ9coyfAb-EHrSUXzdCE,8
+gptdiff-0.1.27.dist-info/RECORD,,

gptdiff-0.1.22.dist-info/RECORD

@@ -1,9 +0,0 @@
-gptdiff/__init__.py,sha256=o1hrK4GFvbfKcHPlLVArz4OunE3euIicEBYaLrdDo0k,198
-gptdiff/gptdiff.py,sha256=AuZwZ1pg52RPheAzdhtZXSTjBGH4t4KRm7r9ziGHJVQ,41388
-gptdiff/gptpatch.py,sha256=Z8CWWIfIL2o7xPLVdhzN5GSyJq0vsK4XQRzu4hMWNQk,2194
-gptdiff-0.1.22.dist-info/LICENSE.txt,sha256=zCJk7yUYpMjFvlipi1dKtaljF8WdZ2NASndBYYbU8BY,1228
-gptdiff-0.1.22.dist-info/METADATA,sha256=_RspqYV4VPaRrpYTQXNVecFirrxzZq7MelPpZLV3O9Q,8785
-gptdiff-0.1.22.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-gptdiff-0.1.22.dist-info/entry_points.txt,sha256=0VlVNr-gc04a3SZD5_qKIBbtg_L5P2x3xlKE5ftcdkc,82
-gptdiff-0.1.22.dist-info/top_level.txt,sha256=XNkQkQGINaDndEwRxg8qToOrJ9coyfAb-EHrSUXzdCE,8
-gptdiff-0.1.22.dist-info/RECORD,,