gptdiff 0.1.21__tar.gz → 0.1.22__tar.gz

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

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

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

@@ -345,7 +345,8 @@ def smartapply(diff_text, files, model=None, api_key=None, base_url=None):
                 del files[path]
         else:
             updated = call_llm_for_apply_with_think_tool_available(path, original, patch, model, api_key=api_key, base_url=base_url)
-            files[path] = updated.strip()
+            cleaned = strip_bad_output(updated, original)
+            files[path] = cleaned
 
     threads = []
 
@@ -585,7 +586,7 @@ def parse_diff_per_file(diff_text):
         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("+++ ") for l in 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]
@@ -778,24 +779,41 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
             else:
                 print(f"\033[1;33mFile {file_path} not found - skipping deletion\033[0m")
             return
-        original_content = ''
-        if full_path.exists():
-            try:
-                original_content = full_path.read_text()
-            except UnicodeDecodeError:
-                print(f"Skipping binary file {file_path}")
-                return
-        if not hasattr(args, "applymodel") or args.applymodel is None:
-            args.applymodel = args.model
-        if args.applymodel is None:
-            args.applymodel = os.getenv("GPTDIFF_MODEL")
+
+        try:
+            original_content = full_path.read_text()
+        except (UnicodeDecodeError, IOError):
+            print(f"Skipping file {file_path} due to read error")
+            return
+
+        # Use SMARTAPPLY-specific environment variables if set, otherwise fallback.
+        smart_apply_model = os.getenv("GPTDIFF_SMARTAPPLY_MODEL")
+        if smart_apply_model and smart_apply_model.strip():
+            model = smart_apply_model
+        elif hasattr(args, "applymodel") and args.applymodel:
+            model = args.applymodel
+        else:
+            model = os.getenv("GPTDIFF_MODEL", "deepseek-reasoner")
+
+        smart_api_key = os.getenv("GPTDIFF_SMARTAPPLY_API_KEY")
+        if smart_api_key and smart_api_key.strip():
+            api_key = smart_api_key
+        else:
+            api_key = os.getenv("GPTDIFF_LLM_API_KEY")
+
+        smart_base_url = os.getenv("GPTDIFF_SMARTAPPLY_BASE_URL")
+        if smart_base_url and smart_base_url.strip():
+            base_url = smart_base_url
+        else:
+            base_url = os.getenv("GPTDIFF_LLM_BASE_URL", "https://nano-gpt.com/api/v1/")
 
         print("-" * 40)
-        print("Running smartapply with", args.applymodel,"on",file_path)
+        print("Running smartapply with", model, "on", file_path)
         print("-" * 40)
         try:
             updated_content = call_llm_for_apply_with_think_tool_available(
-                file_path, original_content, file_diff, args.applymodel,
+                file_path, original_content, file_diff, model,
+                api_key=api_key, base_url=base_url,
                 extra_prompt=f"This changeset is from the following instructions:\n{user_prompt}",
                 max_tokens=args.max_tokens)
             if updated_content.strip() == "":
@@ -1003,5 +1021,29 @@ def swallow_reasoning(full_response: str) -> (str, str):
         final_content = full_response.strip()
     return final_content, reasoning
 
+def strip_bad_output(updated: str, original: str) -> str:
+    """
+    If the original file content does not start with a code fence but the LLM’s updated output
+    starts with triple backticks (possibly with an introductory message), extract and return only
+    the content within the first code block.
+    """
+    updated_stripped = updated.strip()
+    # If the original file does not start with a code fence, but the updated output contains a code block,
+    # extract and return only the content inside the first code block.
+    if not original.lstrip().startswith("```"):
+        # Search for the first code block in the updated output.
+        m = re.search(r"```(.*?)```", updated_stripped, re.DOTALL)
+        if m:
+            content = m.group(1).strip()
+            lines = content.splitlines()
+            if len(lines) > 1:
+                first_line = lines[0].strip()
+                # If the first line appears to be a language specifier (i.e., a single word)
+                # and is not "diff", then drop it.
+                if " " not in first_line and first_line.lower() != "diff":
+                    content = "\n".join(lines[1:]).strip()
+            return content
+    return updated_stripped
+
 if __name__ == "__main__":
-    main()
+    main()

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

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

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

@@ -16,4 +16,5 @@ tests/test_diff_parse.py
 tests/test_failing_case.py
 tests/test_parse_diff_per_file.py
 tests/test_smartapply.py
+tests/test_strip_bad_ouput.py
 tests/test_swallow_reasoning.py

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='gptdiff',
-    version='0.1.21',
+    version='0.1.22',
     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.22/tests/test_strip_bad_ouput.py

@@ -0,0 +1,90 @@
+# File: tests/test_strip_bad_output.py
+import pytest
+from gptdiff.gptdiff import strip_bad_output
+
+def test_strip_bad_output_removes_wrapping():
+    """
+    If the original file content does not start with a code fence,
+    but the LLM output starts with a code block and extra text,
+    then only the content inside the first code block should be returned.
+    """
+    # Original file content does not start with a code fence.
+    original = "def hello():\n    print('Hello')\n"
+    # Simulated LLM output with extraneous text and a code block.
+    updated = (
+        "This is the file you requested:\n"
+        "```diff\n"
+        "def hello():\n"
+        "    print('Goodbye')\n"
+        "```\n"
+        "Thank you!"
+    )
+    # We expect the function to extract only the content inside the code block.
+    expected = "diff\ndef hello():\n    print('Goodbye')"
+    result = strip_bad_output(updated, original)
+    assert result == expected, f"Expected:\n{expected}\nGot:\n{result}"
+
+def test_strip_bad_output_no_change_when_original_has_code_block():
+    """
+    If the original file already starts with a code fence,
+    the function should leave the updated output unchanged.
+    """
+    original = "```diff\ndef hello():\n    print('Hello')\n```"
+    updated = "```diff\ndef hello():\n    print('Modified')\n```"
+    expected = updated.strip()
+    result = strip_bad_output(updated, original)
+    assert result == expected, "Expected no changes when original already starts with a code fence"
+
+def test_strip_bad_output_no_wrapping_detected():
+    """
+    If the updated output does not start with a code fence,
+    the function should return the updated output unchanged.
+    """
+    original = "def hello():\n    print('Hello')\n"
+    updated = "def hello():\n    print('Modified')\n"
+    expected = updated.strip()
+    result = strip_bad_output(updated, original)
+    assert result == expected, "Expected output to remain unchanged if no code block is detected"
+
+
+def test_strip_bad_output_prod_case():
+    """
+    Test that when the updated output includes extraneous introductory text and
+    a language specifier in the code block, the function extracts only the content
+    within the code block (without the language tag or extra text).
+
+    For example, given an updated output like:
+
+        Here's the entire file after applying the diff:
+
+        ```typescript
+        def foo():
+            print('Modified')
+        ```
+        Some trailing text that should be ignored.
+
+    the expected extracted content is:
+
+        def foo():
+            print('Modified')
+    """
+    # Original file content does not start with a code fence.
+    original = "def foo():\n    pass\n"
+
+    # Simulated LLM output with extraneous text, a language specifier ("typescript"),
+    # and trailing text.
+    updated = (
+        "Here's the entire file after applying the diff:\n\n"
+        "```typescript\n"
+        "def foo():\n"
+        "    print('Modified')\n"
+        "```\n"
+        "Some trailing text that should be ignored."
+    )
+
+    # We expect the function to extract only the content inside the first code block,
+    # ignoring the language specifier and any text outside the code block.
+    expected = "def foo():\n    print('Modified')"
+
+    result = strip_bad_output(updated, original)
+    assert result == expected, f"Expected:\n{expected}\nGot:\n{result}"