gptdiff 0.1.30__py3-none-any.whl → 0.1.34__py3-none-any.whl

gptdiff/gptdiff.py

@@ -16,6 +16,7 @@ import contextvars
 from pkgutil import get_data
 import threading
 from threading import Lock
+import shutil
 
 import openai
 from openai import OpenAI
@@ -417,6 +418,10 @@ prepended to the system prompt.
     """
     if model is None:
         model = os.getenv('GPTDIFF_MODEL', 'deepseek-reasoner')
+        # Use ANTHROPIC_BUDGET_TOKENS env var if set and no cli override provided
+        if anthropic_budget_tokens is None:
+            anthropic_budget_tokens = os.getenv('ANTHROPIC_BUDGET_TOKENS')
+    
     if prepend:
         if prepend.startswith("http://") or prepend.startswith("https://"):
             import urllib.request
@@ -428,7 +433,7 @@ prepended to the system prompt.
         prepend = ""
     
     diff_tag = "```diff"
-    system_prompt = prepend + f"Output a git diff into a \"{diff_tag}\" block."
+    system_prompt = prepend + f"Output a full unified git diff into a \"{diff_tag}\" block."
     _, diff_text, _, _, _ = call_llm_for_diff(
         system_prompt, 
         goal, 
@@ -438,7 +443,7 @@ prepended to the system prompt.
         max_tokens=max_tokens,
         api_key=api_key,
         base_url=base_url,
-        budget_tokens=anthropic_budget_tokens
+        budget_tokens=int(anthropic_budget_tokens) if anthropic_budget_tokens is not None else None
     )
     return diff_text
 
@@ -523,7 +528,10 @@ def parse_arguments():
     parser.add_argument('--temperature', type=float, default=1.0, help='Temperature parameter for model creativity (0.0 to 2.0)')
     parser.add_argument('--max_tokens', type=int, default=30000, help='Temperature parameter for model creativity (0.0 to 2.0)')
     parser.add_argument('--model', type=str, default=None, help='Model to use for the API call.')
-    parser.add_argument('--applymodel', type=str, default=None, help='Model to use for applying the diff. Defaults to the value of --model if not specified.')
+    parser.add_argument(
+        '--applymodel', type=str, default=None,
+        help='Model to use for applying the diff. Overrides GPTDIFF_SMARTAPPLY_MODEL env var; if not set, defaults to "openai/gpt-4.1-mini".')
+
     parser.add_argument('--nowarn', action='store_true', help='Disable large token warning')
     parser.add_argument('--anthropic_budget_tokens', type=int, default=None, help='Budget tokens for Anthropic extended thinking')
     parser.add_argument('--verbose', action='store_true', help='Enable verbose output with detailed information')
@@ -698,13 +706,15 @@ def smart_apply_patch(project_dir, diff_text, user_prompt, args):
             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")
-        if smart_apply_model and smart_apply_model.strip():
-            model = smart_apply_model
-        elif hasattr(args, "applymodel") and args.applymodel:
+        # Determine model for smartapply: CLI flag > environment > recommended default
+        if hasattr(args, "applymodel") and args.applymodel:
             model = args.applymodel
         else:
-            model = os.getenv("GPTDIFF_MODEL", "deepseek-reasoner")
+            smart_apply_model = os.getenv("GPTDIFF_SMARTAPPLY_MODEL", "").strip()
+            if smart_apply_model:
+                model = smart_apply_model
+            else:
+                model = 'openai/gpt-4.1-mini'
 
         smart_api_key = os.getenv("GPTDIFF_SMARTAPPLY_API_KEY")
         if smart_api_key and smart_api_key.strip():
@@ -839,7 +849,7 @@ def main():
     if prepend != "":
         prepend += "\n"
 
-    system_prompt = prepend + f"Output a git diff into a ```diff block"
+    system_prompt = prepend + f"Output a full unified git diff into a ```diff block"
 
     files_content = ""
     for file, content in project_files:
@@ -853,11 +863,55 @@ def main():
         args.model = os.getenv('GPTDIFF_MODEL', 'deepseek-reasoner')
 
     if not args.call and not args.apply:
-        with open('prompt.txt', 'w') as f:
-            f.write(full_prompt)
+        """
+        For convenience:
+          • macOS & Linux  → copy prompt directly to the system clipboard
+          • Windows        → fall back to prompt.txt (no reliable native clipboard CLI)
+        """
+        wrote_location = None
+
+        try:
+            if os.name == "nt":
+                # Windows: keep legacy behaviour
+                with open("prompt.txt", "w") as f:
+                    f.write(full_prompt)
+                wrote_location = "prompt.txt"
+            else:
+                # macOS first
+                if sys.platform == "darwin" and shutil.which("pbcopy"):
+                    subprocess.run(["pbcopy"], input=full_prompt.encode(), check=True)
+                    wrote_location = "clipboard (pbcopy)"
+                # Linux – prefer wl-copy, then xclip
+                elif shutil.which("wl-copy"):
+                    subprocess.run(["wl-copy"], input=full_prompt.encode(), check=True)
+                    wrote_location = "clipboard (wl-copy)"
+                elif shutil.which("xclip"):
+                    subprocess.run(
+                        ["xclip", "-selection", "clipboard"],
+                        input=full_prompt.encode(),
+                        check=True,
+                    )
+                    wrote_location = "clipboard (xclip)"
+                # No clipboard utility available – revert to file
+                else:
+                    with open("prompt.txt", "w") as f:
+                        f.write(full_prompt)
+                    wrote_location = "prompt.txt (clipboard utility not found)"
+        except Exception as e:
+            # Any failure falls back to prompt.txt as a safe default
+            print(
+                f"\033[1;31mClipboard write failed: {e}. Falling back to prompt.txt\033[0m"
+            )
+            with open("prompt.txt", "w") as f:
+                f.write(full_prompt)
+            wrote_location = "prompt.txt (clipboard write failed)"
+
         print(f"Total tokens: {token_count:5d}")
-        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"\033[1;32mWrote full prompt to {wrote_location}.\033[0m")
+        if wrote_location.startswith("prompt.txt"):
+            print(
+                "Tip: install 'xclip' or 'wl-clipboard' to enable automatic clipboard copy on Linux."
+            )
         exit(0)
     else:
         # Validate API key presence before any API operations
@@ -929,20 +983,17 @@ def swallow_reasoning(full_response: str) -> (str, str):
         r"(?P<reasoning>>\s*Reasoning.*?Reasoned.*?seconds)",
         re.DOTALL
     )
-    match = pattern.search(full_response)
-    if match:
+    reasoning_list = []
+    def replacer(match):
         raw_reasoning = match.group("reasoning")
-        # Remove any leading '+' characters and extra whitespace from each line
         reasoning_lines = [line.lstrip('+').strip() for line in raw_reasoning.splitlines()]
         reasoning = "\n".join(reasoning_lines).strip()
-
-        # Remove the reasoning block from the response using its exact span
-        final_content = full_response[:match.start()] + full_response[match.end():]
-        final_content = final_content.strip()
-    else:
-        reasoning = ""
-        final_content = full_response.strip()
-    return final_content, reasoning
+        reasoning_list.append(reasoning)
+        return ""
+    
+    final_content = re.sub(pattern, replacer, full_response)
+    reasoning = "\n".join(reasoning_list)
+    return final_content.strip(), reasoning
 
 def strip_bad_output(updated: str, original: str) -> str:
     """

gptdiff/plangptdiff.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+Generate *planprompt.txt* that tells an LLM to run **gptdiff** on only the files
+that matter.
+
+Workflow
+--------
+1. Accept the natural‑language command you would normally give *plan*.
+2. Use **ripgrep** (`rg`) to locate files whose **paths** *or* **contents**
+   match keywords from the command.
+3. Always include any file whose path contains “schema”.
+4. Build a `gptdiff` command pre‑populated with those files.
+5. Write a ready‑to‑paste prompt to **planprompt.txt** –
+   just like `gptdiff` does with *prompt.txt*.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import shlex
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Set
+from gptdiff.gptdiff import load_gitignore_patterns, is_ignored
+
+# LLM helpers
+import json
+from gptdiff.gptdiff import call_llm, domain_for_url
+
+
+# --------------------------------------------------------------------------- #
+# Keyword extraction via LLM                                                  #
+# --------------------------------------------------------------------------- #
+
+def _unique(seq: List[str]) -> List[str]:
+    """Preserve order while removing duplicates."""
+    seen: Set[str] = set()
+    out: List[str] = []
+    for item in seq:
+        if item not in seen:
+            seen.add(item)
+            out.append(item)
+    return out
+
+
+def _parse_keywords(requirement: str) -> List[str]:
+    """
+    Ask the configured **GPTDIFF_MODEL** LLM to emit the most relevant, UNIQUE
+    search terms for *ripgrep*.
+
+    Fallback: returns simple heuristics if no API key is configured or the call
+    fails.
+    """
+    api_key = os.getenv("GPTDIFF_LLM_API_KEY")
+    model = os.getenv("GPTDIFF_MODEL", "deepseek-reasoner")
+    base_url = os.getenv("GPTDIFF_LLM_BASE_URL", "https://nano-gpt.com/api/v1/")
+
+    # Heuristic fallback when no key available
+    if not api_key:
+        return _unique(
+            [w.lower() for w in re.findall(r"[A-Za-z_]{4,}", requirement)]
+        )
+
+    system_prompt = (
+        "You are an expert software search assistant.\n"
+        "Given a natural‑language coding requirement, output **only** a JSON "
+        "array of 3‑10 UNIQUE, lowercase keywords that will best locate the "
+        "relevant source files. Exclude common stop‑words and keep each keyword "
+        "to a single token if possible."
+    )
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": requirement},
+    ]
+
+    try:
+        response = call_llm(
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            messages=messages,
+            max_tokens=128,
+            temperature=0.0,
+        )
+        content = response.choices[0].message.content.strip()
+
+        # In case the model adds commentary, grab the first JSON array found.
+        json_start = content.find("[")
+        json_end = content.rfind("]")
+        if json_start == -1 or json_end == -1:
+            raise ValueError("No JSON array detected.")
+
+        keywords = json.loads(content[json_start : json_end + 1])
+        if not isinstance(keywords, list):
+            raise ValueError("Expected a JSON list of keywords.")
+
+        return _unique([str(k).lower() for k in keywords])
+
+    except Exception as e:  # noqa: BLE001
+        # Print a hint and fall back to heuristic extraction.
+        print(
+            f"\033[33m⚠️  Keyword LLM extraction failed ({e}); "
+            "falling back to simple parsing.\033[0m"
+        )
+        return _unique(
+            [w.lower() for w in re.findall(r"[A-Za-z_]{4,}", requirement)]
+        )
+
+
+def _rg(arguments: List[str]) -> Set[str]:
+    """Thin wrapper around ripgrep – returns an *empty* set if rg isn’t present."""
+    if not shutil.which("rg"):
+        return set()
+
+    completed = subprocess.run(
+        ["rg", "--follow", "--no-config", "--color", "never"] + arguments,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return {p for p in completed.stdout.splitlines() if p}
+
+
+def find_relevant_files(keywords: List[str], include_schema: bool = True) -> List[str]:
+    """Locate files worth passing to gptdiff."""
+    files: Set[str] = set()
+
+    # 1. Path matches
+    for kw in keywords:
+        files |= _rg(["-i", "-g", f"*{kw}*"])
+
+    # 2. Content matches
+    for kw in keywords:
+        files |= _rg(["-i", "--files-with-matches", kw])
+
+    # 3. Anything with “schema” in the path
+    if include_schema:
+        files |= _rg(["-i", "-g", "*schema*"])
+
+    return sorted(files)
+
+
+def build_gptdiff_command(cmd: str, files: List[str], apply: bool) -> str:
+    pieces = ["gptdiff", shlex.quote(cmd)]
+    if files:
+        pieces.append("--files " + " ".join(shlex.quote(f) for f in files))
+    if apply:
+        pieces.append("--apply")
+    return " ".join(pieces)
+
+
+# --------------------------------------------------------------------------- #
+# CLI                                                                         #
+# --------------------------------------------------------------------------- #
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="plangptdiff",
+        description="Create planprompt.txt that invokes gptdiff on relevant files.",
+    )
+    parser.add_argument(
+        "command",
+        nargs=argparse.REMAINDER,
+        help="The natural‑language instruction you would normally give plan.",
+    )
+    parser.add_argument(
+        "--apply",
+        action="store_true",
+        help="Add --apply to the generated gptdiff command.",
+    )
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.error("You must provide a command, e.g.  plangptdiff 'add logging'")
+
+    original_cmd = " ".join(args.command).strip()
+    keywords = _parse_keywords(original_cmd)
+    files = find_relevant_files(keywords)
+
+    # Exclude prompt.txt and any files listed in .gitignore or .gptignore
+    ignore_patterns: List[str] = []
+    cwd = Path.cwd()
+    gitignore_path = cwd / ".gitignore"
+    gptignore_path = cwd / ".gptignore"
+    if gitignore_path.exists():
+        ignore_patterns.extend(load_gitignore_patterns(str(gitignore_path)))
+    if gptignore_path.exists():
+        ignore_patterns.extend(load_gitignore_patterns(str(gptignore_path)))
+    # Always ignore prompt.txt explicitly
+    ignore_patterns.append("prompt.txt")
+    # Filter out ignored files
+    files = [f for f in files if not is_ignored(f, ignore_patterns)]
+
+    gptdiff_cmd = build_gptdiff_command(original_cmd, files, args.apply)
+
+    prompt = f"""You are working in a repository where **gptdiff** is installed.
+Run the command below to implement the requested change:
+
+```bash
+{gptdiff_cmd}
+```"""
+
+    Path("planprompt.txt").write_text(prompt, encoding="utf8")
+    print(f"📝  planprompt.txt written – {len(files)} file(s) included.")
+
+
+if __name__ == "__main__":
+    main()

{gptdiff-0.1.30.dist-info → gptdiff-0.1.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: gptdiff
-Version: 0.1.30
+Version: 0.1.34
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License
@@ -21,6 +21,7 @@ Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: summary
@@ -31,30 +32,48 @@ GPTDiff: Create and apply diffs using AI.
 This tool leverages natural language instructions to modify project codebases.
 -->
 
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Example Usage](#example-usage-of-gptdiff)
+- [Basic Usage](#basic-usage)
+- [Simple Command Line Agent Loops](#simple-command-line-agent-loops)
+- [Why Choose GPTDiff?](#why-choose-gptdiff)
+- [Core Capabilities](#core-capabilities)
+  - [CLI Excellence](#-cli-excellence)
+  - [Magic Diff Generation](#-magic-diff-generation)
+  - [Smart Apply System](#-smart-apply-system)
+- [Get Started](#get-started)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+- [Command Line Usage](#command-line-usage)
+
 🚀 **Create and apply diffs with AI**  
 Modify your project using plain English.
 
-More documentation at [gptdiff.255labs.xyz](gptdiff.255labs.xyz)
+More documentation at [gptdiff.255labs.xyz](https://gptdiff.255labs.xyz)
+
+## Quick Start
 
+1. **Install GPTDiff**
+   
+   
 ### Example Usage of `gptdiff`
 
 #### Apply a Patch Directly
-```
-bash
+```bash
 gptdiff "Add button animations on press" --apply
 ```
 ✅ Successfully applied patch
 
 #### Generate a Patch File
-```
-bash
+```bash
 gptdiff "Add API documentation" --call
 ```
 🔧 Patch written to `diff.patch`
 
 #### Generate a Prompt File Without Calling LLM
-```
-bash
+```bash
 gptdiff "Improve error messages"
 ```
 📄 LLM not called, written to `prompt.txt`
@@ -329,3 +348,20 @@ pytest tests/
 ```
 
 This will execute all unit tests verifying core diff generation and application logic.
+
+### plangptdiff: Generate *plan* prompts that call GPTDiff
+
+`plangptdiff` scans your repo with **ripgrep**, selects only the files likely to
+change (always including anything named *schema*), and writes a ready‑to‑paste
+prompt to **planprompt.txt**:
+
+```bash
+# Prompt only
+plangptdiff "add validation to the signup form"
+
+# Prompt that will auto‑apply the diff
+plangptdiff "upgrade to Django 5" --apply
+```
+
+The file list is appended to the generated `gptdiff` command so the LLM sees
+only the files that matter, keeping prompts lean and costs down.

gptdiff-0.1.34.dist-info/RECORD

@@ -0,0 +1,11 @@
+gptdiff/__init__.py,sha256=o1hrK4GFvbfKcHPlLVArz4OunE3euIicEBYaLrdDo0k,198
+gptdiff/applydiff.py,sha256=FMLkEtNnOdnU7c8LgYafGuROsDz3utpyXKJVFRs_BvI,11473
+gptdiff/gptdiff.py,sha256=Wpj9AReofBFDXdmckqrMsdPONGkVGT9sWh33cApY3_w,39536
+gptdiff/gptpatch.py,sha256=Vqk2vliYs_BxtuTpwdS88n3A8XToh6RvrCA4N8VqOu0,2759
+gptdiff/plangptdiff.py,sha256=EkcBM0xWMYzVpkjg6pe0nZW-SAoqu5vWoTPpgUVz9xA,6934
+gptdiff-0.1.34.dist-info/licenses/LICENSE.txt,sha256=zCJk7yUYpMjFvlipi1dKtaljF8WdZ2NASndBYYbU8BY,1228
+gptdiff-0.1.34.dist-info/METADATA,sha256=ajqqT9MaOuVXOXih2zKPD9YM8I1Hz06za-E4c7uckgQ,9923
+gptdiff-0.1.34.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+gptdiff-0.1.34.dist-info/entry_points.txt,sha256=UX4OYAj1HKIT1JmDQ7fkG6Fbf6Vqfpbojw4psdODR2c,121
+gptdiff-0.1.34.dist-info/top_level.txt,sha256=XNkQkQGINaDndEwRxg8qToOrJ9coyfAb-EHrSUXzdCE,8
+gptdiff-0.1.34.dist-info/RECORD,,

{gptdiff-0.1.30.dist-info → gptdiff-0.1.34.dist-info}/WHEEL

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

{gptdiff-0.1.30.dist-info → gptdiff-0.1.34.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
 gptdiff = gptdiff.gptdiff:main
 gptpatch = gptdiff.gptpatch:main
+plangptdiff = gptdiff.plangptdiff:main

gptdiff-0.1.30.dist-info/RECORD

@@ -1,10 +0,0 @@
-gptdiff/__init__.py,sha256=o1hrK4GFvbfKcHPlLVArz4OunE3euIicEBYaLrdDo0k,198
-gptdiff/applydiff.py,sha256=FMLkEtNnOdnU7c8LgYafGuROsDz3utpyXKJVFRs_BvI,11473
-gptdiff/gptdiff.py,sha256=i2CYCzfIGn5knvNA7Q5mc4EpGR9akka2l3-aMphK0eU,37362
-gptdiff/gptpatch.py,sha256=Vqk2vliYs_BxtuTpwdS88n3A8XToh6RvrCA4N8VqOu0,2759
-gptdiff-0.1.30.dist-info/LICENSE.txt,sha256=zCJk7yUYpMjFvlipi1dKtaljF8WdZ2NASndBYYbU8BY,1228
-gptdiff-0.1.30.dist-info/METADATA,sha256=6pyrzVyjWTsHWggNr7LkjcGefR24P11oXD9w3w_sZFI,8723
-gptdiff-0.1.30.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-gptdiff-0.1.30.dist-info/entry_points.txt,sha256=0VlVNr-gc04a3SZD5_qKIBbtg_L5P2x3xlKE5ftcdkc,82
-gptdiff-0.1.30.dist-info/top_level.txt,sha256=XNkQkQGINaDndEwRxg8qToOrJ9coyfAb-EHrSUXzdCE,8
-gptdiff-0.1.30.dist-info/RECORD,,