kopipasta 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

kopipasta/main.py

@@ -4,6 +4,7 @@ import io
 import json
 import os
 import argparse
+import sys
 import re
 import subprocess
 import tempfile
@@ -17,8 +18,103 @@ import pygments.util
 
 import requests
 
+from pydantic import BaseModel, Field
+import traceback
+from google import genai
+from google.genai.types import GenerateContentConfig
+from prompt_toolkit import prompt # Added for multiline input
+
 FileTuple = Tuple[str, bool, Optional[List[str]], str]
 
+class SimplePatchItem(BaseModel):
+    """A single change described by reasoning, file path, original text, and new text."""
+    reasoning: str = Field(..., description="Explanation for why this specific change is proposed.")
+    file_path: str = Field(..., description="Relative path to the file to be modified.")
+    original_text: str = Field(..., description="The exact, unique block of text to be replaced.")
+    new_text: str = Field(..., description="The text to replace the original_text with.")
+
+class SimplePatchArgs(BaseModel):
+    """A list of proposed code changes."""
+    patches: List[SimplePatchItem] = Field(..., description="A list of patches to apply.")
+
+def apply_simple_patch(patch_item: SimplePatchItem) -> bool:
+    """
+    Applies a single patch defined by replacing original_text with new_text in file_path.
+
+    Validates that the file exists and the original_text is unique.
+    """
+    print(f"\nApplying patch to: {patch_item.file_path}")
+    print(f"Reasoning: {patch_item.reasoning}")
+    print("-" * 20)
+
+    file_path = patch_item.file_path
+    original_text = patch_item.original_text
+    new_text = patch_item.new_text
+
+    # --- Validation ---
+    if not os.path.exists(file_path):
+        print(f"❌ Error: File not found: {file_path}")
+        print("-" * 20)
+        return False
+
+    try:
+        # Read the file content, attempting to preserve line endings implicitly
+        with open(file_path, 'r', encoding='utf-8', newline='') as f:
+            content = f.read()
+
+        # Check for unique occurrence of original_text
+        occurrences = content.count(original_text)
+        if occurrences == 0:
+            print(f"❌ Error: Original text not found in {file_path}.")
+            # Optional: print a snippet of the expected text for debugging
+            # print(f"   Expected original text snippet: '{original_text[:100]}...'")
+            print("-" * 20)
+            return False
+        elif occurrences > 1:
+            print(f"❌ Error: Original text is not unique in {file_path} (found {occurrences} times).")
+            print(f"   Patch cannot be applied automatically due to ambiguity.")
+            # print(f"   Ambiguous original text snippet: '{original_text[:100]}...'")
+            print("-" * 20)
+            return False
+
+        # --- Application ---
+        # Replace the single unique occurrence
+        new_content = content.replace(original_text, new_text, 1)
+
+        # Heuristic to check if a newline might be needed at the end
+        original_ends_with_newline = content.endswith(('\n', '\r'))
+        new_ends_with_newline = new_content.endswith(('\n', '\r'))
+
+        if original_ends_with_newline and not new_ends_with_newline and new_content:
+             # Try to determine the original newline type
+             if content.endswith('\r\n'):
+                 new_content += '\r\n'
+             else: # Assume '\n' otherwise
+                 new_content += '\n'
+        elif not original_ends_with_newline and new_ends_with_newline:
+             # If original didn't end with newline, remove the one added by replacement
+             # This is less common but possible if new_text ends with \n and original_text didn't
+             new_content = new_content.rstrip('\r\n')
+
+
+        # Write the modified content back
+        with open(file_path, 'w', encoding='utf-8', newline='') as f:
+            f.write(new_content)
+
+        print(f"✅ Patch applied successfully to {file_path}.")
+        print("-" * 20)
+        return True
+
+    except IOError as e:
+        print(f"❌ Error reading or writing file {file_path}: {e}")
+        print("-" * 20)
+        return False
+    except Exception as e:
+        print(f"❌ An unexpected error occurred during patch application: {e}")
+        traceback.print_exc()
+        print("-" * 20)
+        return False
+
 def get_colored_code(file_path, code):
      try:
          lexer = get_lexer_for_filename(file_path)
@@ -170,7 +266,7 @@ def split_python_file(file_content):
             code = get_code(prev_end, chunk_start)
             if code.strip():
                 chunks.append((code, prev_end, chunk_start))
-        
+
         # Add the merged chunk
         code = get_code(chunk_start, chunk_end)
         chunks.append((code, chunk_start, chunk_end))
@@ -574,78 +670,19 @@ def fetch_web_content(url: str) -> Tuple[Optional[FileTuple], Optional[str], Opt
         content_type = response.headers.get('content-type', '').lower()
         full_content = response.text
         snippet = full_content[:10000] + "..." if len(full_content) > 10000 else full_content
-        
+
         if 'json' in content_type:
             content_type = 'json'
         elif 'csv' in content_type:
             content_type = 'csv'
         else:
             content_type = 'text'
-        
+
         return (url, False, None, content_type), full_content, snippet
     except requests.RequestException as e:
         print(f"Error fetching content from {url}: {e}")
         return None, None, None
 
-def read_file_content(file_path):
-    _, ext = os.path.splitext(file_path)
-    if ext.lower() == '.json':
-        with open(file_path, 'r') as f:
-            return json.load(f), 'json'
-    elif ext.lower() == '.csv':
-        with open(file_path, 'r') as f:
-            return f.read(), 'csv'
-    else:
-        with open(file_path, 'r') as f:
-            return f.read(), 'text'
-
-def get_content_snippet(content, content_type, max_lines=50, max_chars=4096):
-    if content_type == 'json':
-        return json.dumps(content, indent=2)[:max_chars]
-    elif content_type == 'csv':
-        csv_content = content if isinstance(content, str) else content.getvalue()
-        csv_reader = csv.reader(io.StringIO(csv_content))
-        rows = list(csv_reader)[:max_lines]
-        output = io.StringIO()
-        csv.writer(output).writerows(rows)
-        return output.getvalue()[:max_chars]
-    else:
-        return '\n'.join(content.split('\n')[:max_lines])[:max_chars]
-
-def handle_content(content, content_type, file_or_url):
-    is_large = len(json.dumps(content)) > 102400 if content_type == 'json' else len(content) > 102400
-
-    if is_large:
-        while True:
-            choice = input(f"{file_or_url} is large. View (f)ull content, (s)nippet, or (p)review? ").lower()
-            if choice in ['f', 's', 'p']:
-                break
-            print("Invalid choice. Please enter 'f', 's', or 'p'.")
-
-        if choice == 'f':
-            return content, False
-        elif choice == 's':
-            return get_content_snippet(content, content_type), True
-        else:  # preview
-            preview = get_content_preview(content, content_type)
-            print(f"\nPreview of {file_or_url}:\n{preview}\n")
-            return handle_content(content, content_type, file_or_url)
-    else:
-        return content, False
-
-
-def get_content_preview(content, content_type):
-    if content_type == 'json':
-        return json.dumps(content, indent=2)[:1000] + "\n..."
-    elif content_type == 'csv':
-        csv_content = content if isinstance(content, str) else content.getvalue()
-        csv_reader = csv.reader(io.StringIO(csv_content))
-        rows = list(csv_reader)[:10]
-        output = io.StringIO()
-        csv.writer(output).writerows(rows)
-        return output.getvalue() + "\n..."
-    else:
-        return '\n'.join(content.split('\n')[:20]) + "\n..."
 
 def read_env_file():
     env_vars = {}
@@ -673,14 +710,14 @@ def handle_env_variables(content, env_vars):
     print("Detected environment variables:")
     for key, value in detected_vars:
         print(f"- {key}={value}")
-    
+
     for key, value in detected_vars:
         while True:
             choice = input(f"How would you like to handle {key}? (m)ask / (s)kip / (k)eep: ").lower()
             if choice in ['m', 's', 'k']:
                 break
             print("Invalid choice. Please enter 'm', 's', or 'k'.")
-        
+
         if choice == 'm':
             content = content.replace(value, '*' * len(value))
         elif choice == 's':
@@ -712,7 +749,7 @@ def generate_prompt_template(files_to_include: List[FileTuple], ignore_patterns:
             file_content = read_file_contents(file)
             file_content = handle_env_variables(file_content, env_vars)
             prompt += f"### {relative_path}\n\n```{language}\n{file_content}\n```\n\n"
-    
+
     if web_contents:
         prompt += "## Web Content\n\n"
         for url, (file_tuple, content) in web_contents.items():
@@ -720,7 +757,7 @@ def generate_prompt_template(files_to_include: List[FileTuple], ignore_patterns:
             content = handle_env_variables(content, env_vars)
             language = content_type if content_type in ['json', 'csv'] else ''
             prompt += f"### {url}{' (snippet)' if is_snippet else ''}\n\n```{language}\n{content}\n```\n\n"
-    
+
     prompt += "## Task Instructions\n\n"
     cursor_position = len(prompt)
     prompt += "\n\n"
@@ -779,10 +816,196 @@ def open_editor_for_input(template: str, cursor_position: int) -> str:
     finally:
         os.unlink(temp_file_path)
 
+def start_chat_session(initial_prompt: str):
+    """Starts an interactive chat session with the Gemini API using google-genai."""
+    if not genai:
+        # Error message already printed during import if it failed
+        sys.exit(1)
+
+    # The google-genai library automatically uses GOOGLE_API_KEY env var if set
+    # We still check if it's set to provide a clearer error message upfront
+    if not os.environ.get('GOOGLE_API_KEY'):
+        print("Error: GOOGLE_API_KEY environment variable not set.")
+        print("Please set the GOOGLE_API_KEY environment variable with your API key.")
+        sys.exit(1)
+
+    try:
+        # Create the client - it will use the env var automatically
+        client = genai.Client()
+        print("Google GenAI Client created (using GOOGLE_API_KEY).")
+        # You could add a check here like listing models to verify the key early
+        # print("Available models:", [m.name for m in client.models.list()])
+    except Exception as e:
+        print(f"Error creating Google GenAI client: {e}")
+        print("Please ensure your GOOGLE_API_KEY is valid and has permissions.")
+        sys.exit(1)
+
+    model_name = 'gemini-2.5-pro-exp-03-25'
+    print(f"Using model: {model_name}")
+
+    try:
+        # Create a chat session using the client
+        chat = client.chats.create(model=model_name)
+        # Note: History is managed by the chat object itself
+
+        print("\n--- Starting Interactive Chat with Gemini ---")
+        print("Type /q to quit, /help or /? for help, /patch to request a diff patch.")
+
+        # Send the initial prompt using send_message_stream
+        print("\n🤖 Gemini:")
+        full_response_text = ""
+        # Use send_message_stream for streaming responses
+        response_stream = chat.send_message_stream(initial_prompt)
+        for chunk in response_stream:
+            print(chunk.text, end="", flush=True)
+            full_response_text += chunk.text
+        print("\n" + "-"*20)
+
+        while True:
+            try:
+                # Replace standard input with prompt_toolkit for multiline support
+                user_input = prompt("👤 You (Submit with Esc+Enter or Alt+Enter): ", multiline=True)
+                 # prompt_toolkit raises EOFError on Ctrl+D, so this handler remains correct.
+            except EOFError:
+                 print("\nExiting...")
+                 break
+            except KeyboardInterrupt: # Handle Ctrl+C
+                 print("\nExiting...")
+                 break
+
+            if user_input.lower() == '/q':
+                break
+            elif user_input.strip() == '/patch':
+                print("\n🤖 Gemini: Thinking... (requesting code changes)")
+                # Prompt instructing the model to use the new JSON format
+                patch_request_prompt = (
+                    "Based on our conversation, generate the necessary code changes "
+                    "to fulfill my request. Provide the changes as a JSON list, where each item "
+                    "is an object with the following keys:\n"
+                    "- 'reasoning': Explain why this specific change is needed.\n"
+                    "- 'file_path': The relative path to the file to modify.\n"
+                    "- 'original_text': The exact, unique block of text to replace.\n"
+                    "- 'new_text': The text to replace original_text with.\n"
+                    "Ensure 'original_text' is unique within the specified 'file_path'. "
+                    "Format the response strictly as: { \"patches\": [ { patch_item_1 }, { patch_item_2 }, ... ] }"
+                )
+
+                try:
+                    # Request the response using the new schema
+                    response = chat.send_message(
+                        patch_request_prompt,
+                        config=GenerateContentConfig(
+                            response_schema=SimplePatchArgs.model_json_schema(),
+                            response_mime_type='application/json'
+                        )
+                    )
+
+                    print("🤖 Gemini: Received potential patches.")
+                    try:
+                        # Validate and parse args using the Pydantic model
+                        # Explicitly validate the dictionary returned by response.parsed
+                        if isinstance(response.parsed, dict):
+                            patch_args = SimplePatchArgs.model_validate(response.parsed)
+                        else:
+                            # Handle unexpected type if response.parsed isn't a dict
+                            print(f"❌ Error: Expected a dictionary for patches, but got type {type(response.parsed)}")
+                            print(f"   Content: {response.parsed}")
+                            continue # Skip further processing for this response
+
+                        if not patch_args or not patch_args.patches:
+                            print("🤖 Gemini: No patches were proposed in the response.")
+                            print("-" * 20)
+                            continue
+
+                        print("\nProposed Patches:")
+                        print("=" * 30)
+                        for i, patch_item in enumerate(patch_args.patches):
+                            print(f"Patch {i+1}/{len(patch_args.patches)}:")
+                            print(f"  File: {patch_item.file_path}")
+                            print(f"  Reasoning: {patch_item.reasoning}")
+                            # Optionally show snippets of original/new text for review
+                            print(f"  Original (snippet): '{patch_item.original_text[:80].strip()}...'")
+                            print(f"  New (snippet):      '{patch_item.new_text[:80].strip()}...'")
+                            print("-" * 20)
+
+                        confirm = input(f"Apply these {len(patch_args.patches)} patches? (y/N): ").lower()
+                        if confirm == 'y':
+                            applied_count = 0
+                            failed_count = 0
+                            for patch_item in patch_args.patches:
+                                # Call the new apply function for each patch
+                                success = apply_simple_patch(patch_item)
+                                if success:
+                                    applied_count += 1
+                                else:
+                                    failed_count += 1
+
+                            print("\nPatch Application Summary:")
+                            if applied_count > 0:
+                                print(f"✅ Successfully applied {applied_count} patches.")
+                            if failed_count > 0:
+                                print(f"❌ Failed to apply {failed_count} patches.")
+                            if applied_count == 0 and failed_count == 0: # Should not happen if list wasn't empty
+                                 print("⚪ No patches were applied.")
+                            print("=" * 30)
+                        else:
+                            print("🤖 Gemini: Patches not applied by user.")
+                            print("-" * 20)
+
+                    except Exception as e: # Catch Pydantic validation errors or other issues
+                        print(f"❌ Error processing patch response: {e}")
+                        # Attempt to show the raw response text if parsing failed
+                        raw_text = ""
+                        try:
+                            if response.parts:
+                                raw_text = "".join(part.text for part in response.parts if hasattr(part, 'text'))
+                            elif hasattr(response, 'text'):
+                                raw_text = response.text
+                        except Exception:
+                            pass # Ignore errors getting raw text
+                        if raw_text:
+                           print(f"   Received response text:\n{raw_text}")
+                        else:
+                           print(f"   Received response content: {response}") # Fallback representation
+
+                except Exception as e:
+                    print(f"\n❌ An error occurred while requesting patches from Gemini: {e}")
+                    print("   Please check your connection, API key, and model permissions/capabilities.")
+                    print("-" * 20)
+
+                continue # Go to next loop iteration after handling /patch
+            elif user_input.strip() in ['/help', '/?']:
+                print("🤖 Gemini: Available commands:")
+                print("  /q          - Quit the chat session.")
+                print("  /patch      - Request a diff patch (not fully implemented yet).")
+                print("  /help or /? - Show this help message.")
+                print("-" * 20)
+                continue
+            elif not user_input.strip(): # Ignore empty input
+                continue
+
+            print("\n🤖 Gemini:")
+            full_response_text = ""
+            try:
+                # Use send_message_stream for subsequent messages
+                response_stream = chat.send_message_stream(user_input)
+                for chunk in response_stream:
+                    print(chunk.text, end="", flush=True)
+                    full_response_text += chunk.text
+                print("\n" + "-"*20)
+            except Exception as e:
+                 print(f"\nAn unexpected error occurred: {e}")
+                 print("Try again or type 'exit'.")
+
+    except Exception as e:
+        # Catch other potential errors
+        print(f"\nAn error occurred setting up the chat session: {e}")
+
 def main():
     parser = argparse.ArgumentParser(description="Generate a prompt with project structure, file contents, and web content.")
     parser.add_argument('inputs', nargs='+', help='Files, directories, or URLs to include in the prompt')
     parser.add_argument('-t', '--task', help='Task description for the AI prompt')
+    parser.add_argument('-I', '--interactive', action='store_true', help='Start an interactive chat session after generating the prompt.')
     args = parser.parse_args()
 
     ignore_patterns = read_gitignore()
@@ -801,15 +1024,15 @@ def main():
                 is_large = len(full_content) > 10000
                 if is_large:
                     print(f"\nContent from {input_path} is large. Here's a snippet:\n")
-                    print(snippet)
+                    print(get_colored_code(input_path, snippet))
                     print("\n" + "-"*40 + "\n")
-                    
+
                     while True:
                         choice = input("Use (f)ull content or (s)nippet? ").lower()
                         if choice in ['f', 's']:
                             break
                         print("Invalid choice. Please enter 'f' or 's'.")
-                    
+
                     if choice == 'f':
                         content = full_content
                         is_snippet = False
@@ -822,7 +1045,7 @@ def main():
                     content = full_content
                     is_snippet = False
                     print(f"Content from {input_path} is not large. Using full content.")
-                
+
                 file_tuple = (file_tuple[0], is_snippet, file_tuple[2], file_tuple[3])
                 web_contents[input_path] = (file_tuple, content)
                 current_char_count += len(content)
@@ -901,38 +1124,62 @@ def main():
     print_char_count(current_char_count) # Print final count before prompt generation
     print(f"Summary: Added {len(files_to_include)} files and {len(web_contents)} web sources.")
 
+    added_files_count = len(files_to_include)
+    added_dirs_count = len(processed_dirs) # Count unique processed directories
+    added_web_count = len(web_contents)
+    print(f"Summary: Added {added_files_count} files/patches from {added_dirs_count} directories and {added_web_count} web sources.")
+
     prompt_template, cursor_position = generate_prompt_template(files_to_include, ignore_patterns, web_contents, env_vars)
 
-    if args.task:
-        task_description = args.task
-        # Insert task description before "## Task Instructions"
-        task_marker = "## Task Instructions\n\n"
-        insertion_point = prompt_template.find(task_marker)
-        if insertion_point != -1:
-             final_prompt = prompt_template[:insertion_point + len(task_marker)] + task_description + "\n\n" + prompt_template[insertion_point + len(task_marker):]
-        else: # Fallback if marker not found
-             final_prompt = prompt_template[:cursor_position] + task_description + prompt_template[cursor_position:]
-        print("\nUsing task description from -t argument.")
+    # Logic branching for interactive mode vs. clipboard mode
+    if args.interactive:
+        print("\nPreparing initial prompt for editing...")
+        # Determine the initial content for the editor
+        if args.task:
+            # Pre-populate the task section if --task was provided
+            editor_initial_content = prompt_template[:cursor_position] + args.task + prompt_template[cursor_position:]
+            print("Pre-populating editor with task provided via --task argument.")
+        else:
+            # Use the template as is (user will add task in the editor)
+            editor_initial_content = prompt_template
+            print("Opening editor for you to add the task instructions.")
+
+        # Always open the editor in interactive mode
+        initial_chat_prompt = open_editor_for_input(editor_initial_content, cursor_position)
+        print("Editor closed. Starting interactive chat session...")
+        start_chat_session(initial_chat_prompt) # Start the chat with the edited prompt    else:
     else:
-        print("\nOpening editor for task instructions...")
-        final_prompt = open_editor_for_input(prompt_template, cursor_position)
-
-    print("\n\nGenerated prompt:")
-    print("-" * 80)
-    print(final_prompt)
-    print("-" * 80)
-
-    # Copy the prompt to clipboard
-    try:
-        pyperclip.copy(final_prompt)
-        separator = "\n" + "=" * 40 + "\n☕🍝       Kopipasta Complete!       🍝☕\n" + "=" * 40 + "\n"
-        print(separator)
-        final_char_count = len(final_prompt)
-        final_token_estimate = final_char_count // 4
-        print(f"Prompt has been copied to clipboard. Final size: {final_char_count} characters (~ {final_token_estimate} tokens)")
-    except pyperclip.PyperclipException as e:
-        print(f"\nWarning: Failed to copy to clipboard: {e}")
-        print("You can manually copy the prompt above.")
+        # Original non-interactive behavior
+        if args.task:
+            task_description = args.task
+            # Insert task description before "## Task Instructions"
+            task_marker = "## Task Instructions\n\n"
+            insertion_point = prompt_template.find(task_marker)
+            if insertion_point != -1:
+                final_prompt = prompt_template[:insertion_point + len(task_marker)] + task_description + "\n\n" + prompt_template[insertion_point + len(task_marker):]
+            else: # Fallback if marker not found
+                final_prompt = prompt_template[:cursor_position] + task_description + prompt_template[cursor_position:]
+            print("\nUsing task description from -t argument.")
+        else:
+            print("\nOpening editor for task instructions...")
+            final_prompt = open_editor_for_input(prompt_template, cursor_position)
+
+        print("\n\nGenerated prompt:")
+        print("-" * 80)
+        print(final_prompt)
+        print("-" * 80)
+
+        # Copy the prompt to clipboard
+        try:
+            pyperclip.copy(final_prompt)
+            separator = "\n" + "=" * 40 + "\n☕🍝       Kopipasta Complete!       🍝☕\n" + "=" * 40 + "\n"
+            print(separator)
+            final_char_count = len(final_prompt)
+            final_token_estimate = final_char_count // 4
+            print(f"Prompt has been copied to clipboard. Final size: {final_char_count} characters (~ {final_token_estimate} tokens)")
+        except pyperclip.PyperclipException as e:
+            print(f"\nWarning: Failed to copy to clipboard: {e}")
+            print("You can manually copy the prompt above.")
 
 if __name__ == "__main__":
     main()

kopipasta-0.23.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.1
+Name: kopipasta
+Version: 0.23.0
+Summary: A CLI tool to generate prompts with project structure and file contents
+Home-page: https://github.com/mkorpela/kopipasta
+Author: Mikko Korpela
+Author-email: mikko.korpela@gmail.com
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyperclip==1.9.0
+Requires-Dist: requests==2.32.3
+Requires-Dist: Pygments==2.18.0
+Requires-Dist: google-genai==1.8.0
+Requires-Dist: prompt-toolkit==3.0.50
+
+# kopipasta
+
+[![Version](https://img.shields.io/pypi/v/kopipasta.svg)](https://pypi.python.org/pypi/kopipasta)
+[![Downloads](http://pepy.tech/badge/kopipasta)](http://pepy.tech/project/kopipasta)
+
+Streamline your interaction with LLMs for coding tasks. `kopipasta` helps you provide comprehensive context (project structure, file contents, web content) and facilitates an interactive, patch-based workflow. Go beyond TAB TAB TAB and take control of your LLM context.
+
+<img src="kopipasta.jpg" alt="kopipasta" width="300">
+
+- An LLM told me that kopi means Coffee in some languages.. and a Diffusion model then made this delicious soup.
+
+## Installation
+
+You can install kopipasta using pipx (recommended) or pip:
+
+```bash
+# Using pipx (recommended)
+pipx install kopipasta
+
+# Or using pip
+pip install kopipasta
+```
+
+## Usage
+
+```bash
+kopipasta [options] [files_or_directories_or_urls...]
+```
+
+**Arguments:**
+
+*   `[files_or_directories_or_urls...]`: Paths to files, directories, or web URLs to include as context.
+
+**Options:**
+
+*   `-t TASK`, `--task TASK`: Provide the task description directly via the command line. If omitted (and not using `-I`), an editor will open for you to write the task.
+*   `-I`, `--interactive`: Start an interactive chat session with Google's Gemini model after preparing the context. Requires `GOOGLE_API_KEY` environment variable.
+
+**Examples:**
+
+1.  **Generate prompt and copy to clipboard (classic mode):**
+    ```bash
+    # Interactively select files from src/, include config.json, fetch web content,
+    # then open editor for task input. Copy final prompt to clipboard.
+    kopipasta src/ config.json https://example.com/api-docs
+
+    # Provide task directly, include specific files, copy final prompt.
+    kopipasta -t "Refactor setup.py to read deps from requirements.txt" setup.py requirements.txt
+    ```
+
+2.  **Start an interactive chat session:**
+    ```bash
+    # Interactively select files, provide task directly, then start chat.
+    kopipasta -I -t "Implement the apply_simple_patch function" kopipasta/main.py
+
+    # Interactively select files, open editor for initial task, then start chat.
+    kopipasta -I kopipasta/ tests/
+    ```
+
+## Workflow
+
+`kopipasta` is designed to support the following workflow when working with LLMs (like Gemini, ChatGPT, Claude, etc.) for coding tasks:
+
+1.  **Gather Context:** Run `kopipasta` with the relevant files, directories, and URLs. Interactively select exactly what content (full files, snippets, or specific code chunks/patches) should be included.
+2.  **Define Task:** Provide your coding task instructions, either via the `-t` flag or through your default editor.
+3.  **Interact (if using `-I`):**
+    *   `kopipasta` prepares the context and your task as an initial prompt.
+    *   An interactive chat session starts (currently using Google Gemini via `google-genai`).
+    *   Discuss the task, clarify requirements, and ask the LLM to generate code.
+    *   The initial prompt includes instructions guiding the LLM to provide incremental changes and clear explanations.
+4.  **Request Patches (`-I` mode):**
+    *   During the chat, use the `/patch` command to ask the LLM to provide the proposed changes in a structured format.
+    *   `kopipasta` will prompt you to review the proposed patches (file, reasoning, code change).
+5.  **Apply Patches (`-I` mode):**
+    *   If you approve, `kopipasta` will attempt to automatically apply the patches to your local files. It validates that the original code exists and is unique before applying.
+6.  **Test & Iterate:** Test the changes locally. If further changes are needed, continue the chat, request new patches, or make manual edits.
+7.  **Commit:** Once satisfied, commit the changes.
+
+For non-interactive mode, `kopipasta` generates the complete prompt (context + task) and copies it to your clipboard (Step 1 & 2). You can then paste this into your preferred LLM interface and proceed manually from Step 3 onwards.
+
+## Features
+
+*   **Comprehensive Context Generation:** Creates structured prompts including:
+    *   Project directory tree overview.
+    *   Selected file contents.
+    *   Content fetched from web URLs.
+    *   Your specific task instructions.
+*   **Interactive File Selection:**
+    *   Guides you through selecting files and directories.
+    *   Option to include full file content, a snippet (first lines/bytes), or **select specific code chunks/patches** for large or complex files.
+    *   Syntax highlighting during chunk selection for supported languages.
+    *   Ignores files based on common `.gitignore` patterns and detects binary files.
+    *   Displays estimated character/token counts during selection.
+*   **Web Content Fetching:** Includes content directly from URLs. Handles JSON/CSV content types.
+*   **Editor Integration:** Opens your preferred editor (`$EDITOR`) to input task instructions (if not using `-t`).
+*   **Environment Variable Handling:** Detects potential secrets from a `.env` file in included content and prompts you to mask, skip, or keep them.
+*   **Clipboard Integration:** Automatically copies the generated prompt to the clipboard (non-interactive mode).
+*   **Interactive Chat Mode (`-I`, `--interactive`):**
+    *   Starts a chat session directly after context generation.
+    *   Uses the `google-genai` library to interact with Google's Gemini models.
+    *   Requires the `GOOGLE_API_KEY` environment variable to be set.
+    *   Includes built-in instructions for the LLM to encourage clear, iterative responses.
+*   **Patch Management (`-I` mode):**
+    *   `/patch` command to request structured code changes from the LLM.
+    *   Prompts user to review proposed patches (reasoning, file, original/new code snippets).
+    *   **Automatic patch application** to local files upon confirmation.
+
+## Configuration
+
+*   **Editor:** Set the `EDITOR` environment variable to your preferred command-line editor (e.g., `vim`, `nvim`, `nano`, `emacs`, `code --wait`).
+*   **API Key (for `-I` mode):** Set the `GOOGLE_API_KEY` environment variable with your Google AI Studio API key to use the interactive chat feature.
+
+## Real life example (Non-Interactive)
+
+Context: I had a bug where `setup.py` didn't include all dependencies listed in `requirements.txt`.
+
+1.  `kopipasta -t "Update setup.py to read dependencies dynamically from requirements.txt" setup.py requirements.txt`
+2.  Paste the generated prompt (copied to clipboard) into my preferred LLM chat interface.
+3.  Review the LLM's proposed code.
+4.  Copy the code and update `setup.py` manually.
+5.  Test the changes.
+
+## Real life example (Interactive)
+
+Context: I want to refactor a function in `main.py`.
+
+1.  `export GOOGLE_API_KEY="YOUR_API_KEY_HERE"` (ensure key is set)
+2.  `kopipasta -I -t "Refactor the handle_content function in main.py to be more modular" module/main.py`
+3.  The tool gathers context, shows the file size, and confirms inclusion.
+4.  An interactive chat session starts with the context and task sent to Gemini.
+5.  Chat with the LLM:
+    *   *User:* "Proceed"
+    *   *LLM:* "Okay, I understand. My plan is to..."
+    *   *User:* "Looks good."
+    *   *LLM:* "Here's the first part of the refactoring..." (shows code)
+6.  Use the `/patch` command:
+    *   *User:* `/patch`
+    *   `kopipasta` asks the LLM for structured patches.
+    *   `kopipasta` displays proposed patches: "Apply 1 patch to module/main.py? (y/N):"
+7.  Apply the patch:
+    *   *User:* `y`
+    *   `kopipasta` applies the change to `module/main.py`.
+8.  Test locally. If it works, commit. If not, continue chatting, request more patches, or debug.
+

kopipasta-0.23.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kopipasta/main.py,sha256=dcgcuIlPEjFoRdFwyBLQFRkFzFaIyhJEBiCeeZFFRR0,52209
+kopipasta-0.23.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
+kopipasta-0.23.0.dist-info/METADATA,sha256=2knuAlALtbnaEbxpXJuC3GgnAAOCOPQfowV6GIjT5ts,8610
+kopipasta-0.23.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+kopipasta-0.23.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
+kopipasta-0.23.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
+kopipasta-0.23.0.dist-info/RECORD,,

{kopipasta-0.21.0.dist-info → kopipasta-0.23.0.dist-info}/WHEEL

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

kopipasta-0.21.0.dist-info/METADATA

@@ -1,94 +0,0 @@
-Metadata-Version: 2.1
-Name: kopipasta
-Version: 0.21.0
-Summary: A CLI tool to generate prompts with project structure and file contents
-Home-page: https://github.com/mkorpela/kopipasta
-Author: Mikko Korpela
-Author-email: mikko.korpela@gmail.com
-License: MIT
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyperclip ==1.9.0
-Requires-Dist: requests ==2.32.3
-Requires-Dist: Pygments ==2.18.0
-
-# kopipasta
-
-[![Version](https://img.shields.io/pypi/v/kopipasta.svg)](https://pypi.python.org/pypi/kopipasta)
-[![Downloads](http://pepy.tech/badge/kopipasta)](http://pepy.tech/project/kopipasta)
-
-Beyond TAB TAB TAB. Giving you full control of the context.
-
-A CLI tool for generating code task prompts with project structure and file contents, using an interactive editor-based workflow. OR a very easy way to give a large context to an LLM.
-
-<img src="kopipasta.jpg" alt="kopipasta" width="300">
-
-- An LLM told me that kopi means Coffee in some languages.. and a Diffusion model then made this delicious soup.
-
-## Installation
-
-You can install kopipasta using pipx (or pip):
-
-```bash
-pipx install kopipasta
-```
-
-## Usage
-
-To use kopipasta, run the following command in your terminal:
-
-```bash
-kopipasta [files_or_directories_or_urls]
-```
-
-Replace `[files_or_directories_or_urls]` with the paths to the files or directories you want to include in the prompt, as well as any web URLs you want to fetch content from.
-
-Example input:
-```bash
-kopipasta src/ config.json https://example.com/api-docs
-```
-
-This will guide you through an interactive process to:
-1. Select files and directories to include in the prompt
-2. Choose between full content, snippets, or patches for large files
-3. Fetch and include content from provided URLs
-4. Open an editor for you to input the specific task or code generation instructions
-5. Generate a comprehensive prompt that includes project structure, selected file contents, and your task instructions
-
-The generated prompt will be displayed in the console and automatically copied to your clipboard, ready to be used with an AI code generation tool.
-
-## Features
-
-- Generates structured prompts with project overview, file contents, web content, and task instructions
-- Interactive file selection process with options for full content, snippets, or specific patches
-- Fetches and includes content from web URLs
-- Opens your preferred editor (configurable via EDITOR environment variable) for task input
-- Detects and securely handles environment variables from a `.env` file
-- Ignores files and directories based on common .gitignore patterns
-- Allows interactive selection of files to include
-- Supports various file types with syntax highlighting in the selection process
-- Automatically copies the generated prompt to the clipboard
-
-## Real life example
-
-Context:
-I had a bug that setup.py did not have all the dependencies. I wanted to make things easier:
-
-1. `kopipasta -t "setup.py should take requirements from requirements.txt" requirements.txt setup.py`
-2. Opened the service that provides the best LLM currently.
-3. Pasted the prompt to their chat.
-4. Reviewed the first message and typed "Proceed".
-5. Got back the code that fixed the issue.
-
-

kopipasta-0.21.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kopipasta/main.py,sha256=69m3sVRwqYfEsqk_IukhfrC_ZIx-bjvNc1z_hZQ2zrM,39318
-kopipasta-0.21.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
-kopipasta-0.21.0.dist-info/METADATA,sha256=NNROfNVFYI-1tllgg2_O-Cfua4cNKHXKlDN8GPhYMu4,3716
-kopipasta-0.21.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-kopipasta-0.21.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
-kopipasta-0.21.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
-kopipasta-0.21.0.dist-info/RECORD,,