gptdiff 0.1.20__tar.gz → 0.1.22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.20
+Version: 0.1.22
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License
@@ -10,7 +10,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: openai>=1.0.0
 Requires-Dist: tiktoken>=0.5.0
-Requires-Dist: ai_agent_toolbox>=0.1.13
+Requires-Dist: ai-agent-toolbox>=0.1.15
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"

{gptdiff-0.1.20 → 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() == "":
@@ -985,17 +1003,47 @@ def swallow_reasoning(full_response: str) -> (str, str):
          - reasoning: The extracted reasoning block, or an empty string if not found.
     """
     pattern = re.compile(
-        r"(?P<reasoning>>\s*Reasoning.*?Reasoned for \d+\s*seconds)",
+        r"(?P<reasoning>>\s*Reasoning.*?Reasoned.*?seconds)",
         re.DOTALL
     )
     match = pattern.search(full_response)
     if match:
-        reasoning = match.group("reasoning").strip()
-        final_content = full_response.replace(reasoning, "").strip()
+        raw_reasoning = match.group("reasoning")
+        # Remove any leading '+' characters and extra whitespace from each line
+        reasoning_lines = [line.lstrip('+').strip() for line in raw_reasoning.splitlines()]
+        reasoning = "\n".join(reasoning_lines).strip()
+
+        # Remove the reasoning block from the response using its exact span
+        final_content = full_response[:match.start()] + full_response[match.end():]
+        final_content = final_content.strip()
     else:
         reasoning = ""
         final_content = full_response.strip()
     return final_content, reasoning
 
+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()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.20
+Version: 0.1.22
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License
@@ -10,7 +10,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: openai>=1.0.0
 Requires-Dist: tiktoken>=0.5.0
-Requires-Dist: ai_agent_toolbox>=0.1.13
+Requires-Dist: ai-agent-toolbox>=0.1.15
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"

{gptdiff-0.1.20 → 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.20 → gptdiff-0.1.22}/gptdiff.egg-info/requires.txt

@@ -1,6 +1,6 @@
 openai>=1.0.0
 tiktoken>=0.5.0
-ai_agent_toolbox>=0.1.13
+ai-agent-toolbox>=0.1.15
 
 [docs]
 mkdocs

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='gptdiff',
-    version='0.1.20',
+    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
@@ -12,7 +12,7 @@ setup(
     install_requires=[
         'openai>=1.0.0',
         'tiktoken>=0.5.0',
-        'ai_agent_toolbox>=0.1.13'
+        'ai-agent-toolbox>=0.1.15'
     ],
     extras_require={
         'test': ['pytest', 'pytest-mock'],

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}"

gptdiff-0.1.22/tests/test_swallow_reasoning.py

@@ -0,0 +1,156 @@
+import pytest
+
+from gptdiff.gptdiff import swallow_reasoning
+
+def test_swallow_reasoning_extraction():
+    llm_response = (
+        "+> Reasoning\n"
+        "+None\n"
+        "+Reasoned about summary drawer button 변경 for 15 seconds\n"
+        "+def new():\n"
+        "```"
+    )
+    final_content, reasoning = swallow_reasoning(llm_response)
+    expected_reasoning = (
+        "> Reasoning\n"
+        "**Applying the diff**\n"
+        "I'm piecing together how to efficiently apply a diff to a file...\n"
+        "**Returning the result**\n"
+        "I'm finalizing the method to apply the diff updates...\n"
+        "Reasoned for 6 seconds"
+    )
+    assert reasoning == expected_reasoning
+    # The final content should no longer contain the reasoning block.
+    assert expected_reasoning not in final_content
+    # And it should contain the diff block.
+    assert "```diff" in final_content
+
+
+def test_swallow_reasoning_with_untested_response():
+    llm_response = (
+        "> Reasoning\n"
+        "**Considering the request**\n"
+        "I’m noting that the user wants me to apply a diff to a file and return the result in a block, ensuring the entire file is included.\n"
+        "**Ensuring comprehensive inclusion**\n"
+        "I'm making sure the entire file is included when presenting the result in a block, following the user's request carefully.\n"
+        "**Ensuring clarity**\n"
+        "I’m integrating the diff into the file and ensuring the entire file is returned as requested. This approach maintains precision and clarity in the response.\n"
+        "**Refining the response**\n"
+        "I’m focusing on how to structure the response by carefully integrating the diff and ensuring the entire file is included in a clear block format.\n"
+        "**Connecting the pieces**\n"
+        "I'm mapping out how to apply the diff to the file carefully and ensure the entire file is incorporated into the final block.\n"
+        "Reasoned for a few seconds\n"
+        "\n"
+        "```diff\n"
+        "--- a/file.py\n"
+        "+++ b/file.py\n"
+        "@@ -1,2 +1,2 @@\n"
+        "-def old():\n"
+        "+def new():\n"
+        "```"
+    )
+    final_content, reasoning = swallow_reasoning(llm_response)
+
+    expected_reasoning = (
+        "> Reasoning\n"
+        "**Considering the request**\n"
+        "I’m noting that the user wants me to apply a diff to a file and return the result in a block, ensuring the entire file is included.\n"
+        "**Ensuring comprehensive inclusion**\n"
+        "I'm making sure the entire file is included when presenting the result in a block, following the user's request carefully.\n"
+        "**Ensuring clarity**\n"
+        "I’m integrating the diff into the file and ensuring the entire file is returned as requested. This approach maintains precision and clarity in the response.\n"
+        "**Refining the response**\n"
+        "I’m focusing on how to structure the response by carefully integrating the diff and ensuring the entire file is included in a clear block format.\n"
+        "**Connecting the pieces**\n"
+        "I'm mapping out how to apply the diff to the file carefully and ensure the entire file is incorporated into the final block.\n"
+        "Reasoned for a few seconds"
+    )
+
+    assert reasoning == expected_reasoning
+    # The final content should no longer contain the reasoning block.
+    assert expected_reasoning not in final_content
+    # And it should contain the diff block.
+    assert "```diff" in final_content
+
+def test_swallow_reasoning_extraction():
+    llm_response = (
+        "> Reasoning\n"
+        "**Applying the diff**\n"
+        "I'm piecing together how to efficiently apply a diff to a file...\n"
+        "**Returning the result**\n"
+        "I'm finalizing the method to apply the diff updates...\n"
+        "Reasoned for 6 seconds\n"
+        "\n"
+        "```diff\n"
+        "--- a/file.py\n"
+        "+++ b/file.py\n"
+        "@@ -1,2 +1,2 @@\n"
+        "-def old():\n"
+        "+def new():\n"
+        "```"
+    )
+    final_content, reasoning = swallow_reasoning(llm_response)
+    expected_reasoning = (
+        "> Reasoning\n"
+        "**Applying the diff**\n"
+        "I'm piecing together how to efficiently apply a diff to a file...\n"
+        "**Returning the result**\n"
+        "I'm finalizing the method to apply the diff updates...\n"
+        "Reasoned for 6 seconds"
+    )
+    assert reasoning == expected_reasoning
+    # The final content should no longer contain the reasoning block.
+    assert expected_reasoning not in final_content
+    # And it should contain the diff block.
+    assert "```diff" in final_content
+
+
+def test_swallow_reasoning_no_reasoning():
+    llm_response = (
+        "```diff\n"
+        "--- a/file.py\n"
+        "+++ b/file.py\n"
+        "@@ -1,2 +1,2 @@\n"
+        "-def old():\n"
+        "+def new():\n"
+        "```"
+    )
+    final_content, reasoning = swallow_reasoning(llm_response)
+    assert reasoning == ""
+    assert final_content == llm_response.strip()
+
+def test_swallow_reasoning_inline_newlines():
+    llm_response = (
+        "Prefix text before reasoning and some inline content "
+        "> Reasoning\n"
+        "Inline line 1\n"
+        "Inline line 2\n"
+        "Reasoned for 2 seconds "
+        "and then suffix text.\n"
+        "```diff\n"
+        "--- a/inline.py\n"
+        "+++ b/inline.py\n"
+        "@@ -1,2 +1,2 @@\n"
+        "-print('Old')\n"
+        "+print('New')\n"
+        "```"
+    )
+    final_content, reasoning = swallow_reasoning(llm_response)
+    expected_reasoning = (
+        "> Reasoning\n"
+        "Inline line 1\n"
+        "Inline line 2\n"
+        "Reasoned for 2 seconds"
+    )
+    # Count the newlines in the extracted reasoning block.
+    newline_count = reasoning.count('\n')
+    # There should be 3 newline characters: after "> Reasoning", after "Inline line 1", and after "Inline line 2"
+    assert newline_count == 3, f"Expected 3 newlines, got {newline_count}"
+    assert reasoning == expected_reasoning
+    # Ensure the reasoning block is removed from the final content.
+    assert expected_reasoning not in final_content
+    # Verify that surrounding content remains.
+    assert "Prefix text before reasoning" in final_content
+    assert "and then suffix text." in final_content
+    # Verify that the diff block is still present.
+    assert "```diff" in final_content

gptdiff-0.1.20/tests/test_swallow_reasoning.py

@@ -1,51 +0,0 @@
-import pytest
-
-from gptdiff.gptdiff import swallow_reasoning
-
-
-def test_swallow_reasoning_extraction():
-    llm_response = (
-        "> Reasoning\n"
-        "**Applying the diff**\n"
-        "I'm piecing together how to efficiently apply a diff to a file...\n"
-        "**Returning the result**\n"
-        "I'm finalizing the method to apply the diff updates...\n"
-        "Reasoned for 6 seconds\n"
-        "\n"
-        "```diff\n"
-        "--- a/file.py\n"
-        "+++ b/file.py\n"
-        "@@ -1,2 +1,2 @@\n"
-        "-def old():\n"
-        "+def new():\n"
-        "```"
-    )
-    final_content, reasoning = swallow_reasoning(llm_response)
-    expected_reasoning = (
-        "> Reasoning\n"
-        "**Applying the diff**\n"
-        "I'm piecing together how to efficiently apply a diff to a file...\n"
-        "**Returning the result**\n"
-        "I'm finalizing the method to apply the diff updates...\n"
-        "Reasoned for 6 seconds"
-    )
-    assert reasoning == expected_reasoning
-    # The final content should no longer contain the reasoning block.
-    assert expected_reasoning not in final_content
-    # And it should contain the diff block.
-    assert "```diff" in final_content
-
-
-def test_swallow_reasoning_no_reasoning():
-    llm_response = (
-        "```diff\n"
-        "--- a/file.py\n"
-        "+++ b/file.py\n"
-        "@@ -1,2 +1,2 @@\n"
-        "-def old():\n"
-        "+def new():\n"
-        "```"
-    )
-    final_content, reasoning = swallow_reasoning(llm_response)
-    assert reasoning == ""
-    assert final_content == llm_response.strip()