kopipasta 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

kopipasta/import_parser.py

@@ -1,5 +1,3 @@
-# kopipasta/import_parser.py
-
 import os
 import re
 import json

kopipasta/main.py

@@ -1,10 +1,8 @@
 #!/usr/bin/env python3
 import csv
 import io
-import json
 import os
 import argparse
-import sys
 import re
 import subprocess
 import tempfile
@@ -18,102 +16,112 @@ 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
+import kopipasta.import_parser as import_parser
 
 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:
+def _propose_and_add_dependencies(
+    file_just_added: str,
+    project_root_abs: str,
+    files_to_include: List[FileTuple],
+    current_char_count: int
+) -> Tuple[List[FileTuple], int]:
     """
-    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.
+    Analyzes a file for local dependencies and interactively asks the user to add them.
     """
-    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
+    language = get_language_for_file(file_just_added)
+    if language not in ['python', 'typescript', 'javascript', 'tsx', 'jsx']:
+        return [], 0 # Only analyze languages we can parse
+
+    print(f"Analyzing {get_relative_path(file_just_added)} for local dependencies...")
 
     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
+        file_content = read_file_contents(file_just_added)
+        if not file_content:
+            return [], 0
+
+        resolved_deps_abs: Set[str] = set()
+        if language == 'python':
+            resolved_deps_abs = import_parser.parse_python_imports(file_content, file_just_added, project_root_abs)
+        elif language in ['typescript', 'javascript', 'tsx', 'jsx']:
+            resolved_deps_abs = import_parser.parse_typescript_imports(file_content, file_just_added, project_root_abs)
+
+        # Filter out dependencies that are already in the context
+        included_paths = {os.path.abspath(f[0]) for f in files_to_include}
+        suggested_deps = sorted([
+            dep for dep in resolved_deps_abs
+            if os.path.abspath(dep) not in included_paths and os.path.abspath(dep) != os.path.abspath(file_just_added)
+        ])
+
+        if not suggested_deps:
+            print("No new local dependencies found.")
+            return [], 0
+
+        print(f"\nFound {len(suggested_deps)} new local {'dependency' if len(suggested_deps) == 1 else 'dependencies'}:")
+        for i, dep_path in enumerate(suggested_deps):
+            print(f"  ({i+1}) {get_relative_path(dep_path)}")
+
+        while True:
+            choice = input("\nAdd dependencies? (a)ll, (n)one, or enter numbers (e.g. 1, 3-4): ").lower()
+            
+            deps_to_add_paths = None
+            if choice == 'a':
+                deps_to_add_paths = suggested_deps
+                break
+            if choice == 'n':
+                deps_to_add_paths = []
+                print(f"Skipped {len(suggested_deps)} dependencies.")
+                break
+
+            # Try to parse the input as numbers directly.
+            try:
+                selected_indices = set()
+                parts = choice.replace(' ', '').split(',')
+                if all(p.strip() for p in parts): # Ensure no empty parts like in "1,"
+                    for part in parts:
+                        if '-' in part:
+                            start_str, end_str = part.split('-', 1)
+                            start = int(start_str)
+                            end = int(end_str)
+                            if start > end:
+                                start, end = end, start
+                            selected_indices.update(range(start - 1, end))
+                        else:
+                            selected_indices.add(int(part) - 1)
+
+                    # Validate that all selected numbers are within the valid range
+                    if all(0 <= i < len(suggested_deps) for i in selected_indices):
+                        deps_to_add_paths = [
+                            suggested_deps[i] for i in sorted(list(selected_indices))
+                        ]
+                        break # Success! Exit the loop.
+                    else:
+                        print(f"Error: Invalid number selection. Please choose numbers between 1 and {len(suggested_deps)}.")
+                else:
+                    raise ValueError("Empty part detected in input.")
+
+
+            except ValueError:
+                # This will catch any input that isn't 'a', 'n', or a valid number/range.
+                print("Invalid choice. Please enter 'a', 'n', or a list/range of numbers (e.g., '1,3' or '2-4').")
+        
+        if not deps_to_add_paths:
+            return [], 0 # No dependencies were selected
+
+        newly_added_files: List[FileTuple] = []
+        char_count_delta = 0
+        for dep_path in deps_to_add_paths:
+            # Assume non-large for now for simplicity, can be enhanced later
+            file_size = os.path.getsize(dep_path)
+            newly_added_files.append((dep_path, False, None, get_language_for_file(dep_path)))
+            char_count_delta += file_size
+            print(f"Added dependency: {get_relative_path(dep_path)} ({get_human_readable_size(file_size)})")
+
+        return newly_added_files, char_count_delta
 
-        # --- 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
+        print(f"Warning: Could not analyze dependencies for {get_relative_path(file_just_added)}: {e}")
+        return [], 0
 
 def get_colored_code(file_path, code):
      try:
@@ -540,7 +548,7 @@ def print_char_count(count):
     token_estimate = count // 4
     print(f"\rCurrent prompt size: {count} characters (~ {token_estimate} tokens)", flush=True)
 
-def select_files_in_directory(directory: str, ignore_patterns: List[str], current_char_count: int = 0) -> Tuple[List[FileTuple], int]:
+def select_files_in_directory(directory: str, ignore_patterns: List[str], project_root_abs: str, current_char_count: int = 0) -> Tuple[List[FileTuple], int]:
     files = [f for f in os.listdir(directory)
              if os.path.isfile(os.path.join(directory, f)) and not is_ignored(os.path.join(directory, f), ignore_patterns) and not is_binary(os.path.join(directory, f))]
 
@@ -561,7 +569,9 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
         print_char_count(current_char_count)
         choice = input("(y)es add all / (n)o ignore all / (s)elect individually / (q)uit? ").lower()
         selected_files: List[FileTuple] = []
+        char_count_delta = 0
         if choice == 'y':
+            files_to_add_after_loop = []
             for file in files:
                 file_path = os.path.join(directory, file)
                 if is_large_file(file_path):
@@ -571,14 +581,23 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
                             break
                         print("Invalid choice. Please enter 'f' or 's'.")
                     if snippet_choice == 's':
-                        selected_files.append((file, True, None, get_language_for_file(file)))
-                        current_char_count += len(get_file_snippet(file_path))
+                        selected_files.append((file_path, True, None, get_language_for_file(file_path)))
+                        char_count_delta += len(get_file_snippet(file_path))
                     else:
-                        selected_files.append((file, False, None, get_language_for_file(file)))
-                        current_char_count += os.path.getsize(file_path)
+                        selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                        char_count_delta += os.path.getsize(file_path)
                 else:
-                    selected_files.append((file, False, None, get_language_for_file(file)))
-                    current_char_count += os.path.getsize(file_path)
+                    selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                    char_count_delta += os.path.getsize(file_path)
+                files_to_add_after_loop.append(file_path)
+
+            # Analyze dependencies after the loop
+            current_char_count += char_count_delta
+            for file_path in files_to_add_after_loop:
+                 new_deps, deps_char_count = _propose_and_add_dependencies(file_path, project_root_abs, selected_files, current_char_count)
+                 selected_files.extend(new_deps)
+                 current_char_count += deps_char_count
+
             print(f"Added all files from {directory}")
             return selected_files, current_char_count
         elif choice == 'n':
@@ -596,6 +615,7 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
                         print_char_count(current_char_count)
                     file_choice = input(f"{file} ({file_size_readable}, ~{file_char_estimate} chars, ~{file_token_estimate} tokens) (y/n/p/q)? ").lower()
                     if file_choice == 'y':
+                        file_to_add = None
                         if is_large_file(file_path):
                             while True:
                                 snippet_choice = input(f"{file} is large. Use (f)ull content or (s)nippet? ").lower()
@@ -603,14 +623,21 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
                                     break
                                 print("Invalid choice. Please enter 'f' or 's'.")
                             if snippet_choice == 's':
-                                selected_files.append((file, True, None, get_language_for_file(file_path)))
+                                file_to_add = (file_path, True, None, get_language_for_file(file_path))
                                 current_char_count += len(get_file_snippet(file_path))
                             else:
-                                selected_files.append((file, False, None, get_language_for_file(file_path)))
+                                file_to_add = (file_path, False, None, get_language_for_file(file_path))
                                 current_char_count += file_char_estimate
                         else:
-                            selected_files.append((file, False, None, get_language_for_file(file_path)))
+                            file_to_add = (file_path, False, None, get_language_for_file(file_path))
                             current_char_count += file_char_estimate
+                        
+                        if file_to_add:
+                            selected_files.append(file_to_add)
+                            # Analyze dependencies immediately after adding
+                            new_deps, deps_char_count = _propose_and_add_dependencies(file_path, project_root_abs, selected_files, current_char_count)
+                            selected_files.extend(new_deps)
+                            current_char_count += deps_char_count
                         break
                     elif file_choice == 'n':
                         break
@@ -633,7 +660,7 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
         else:
             print("Invalid choice. Please try again.")
 
-def process_directory(directory: str, ignore_patterns: List[str], current_char_count: int = 0) -> Tuple[List[FileTuple], Set[str], int]:
+def process_directory(directory: str, ignore_patterns: List[str], project_root_abs: str, current_char_count: int = 0) -> Tuple[List[FileTuple], Set[str], int]:
     files_to_include: List[FileTuple] = []
     processed_dirs: Set[str] = set()
 
@@ -647,10 +674,10 @@ def process_directory(directory: str, ignore_patterns: List[str], current_char_c
         print(f"\nExploring directory: {root}")
         choice = input("(y)es explore / (n)o skip / (q)uit? ").lower()
         if choice == 'y':
-            selected_files, current_char_count = select_files_in_directory(root, ignore_patterns, current_char_count)
-            for file_tuple in selected_files:
-                full_path = os.path.join(root, file_tuple[0])
-                files_to_include.append((full_path, file_tuple[1], file_tuple[2], file_tuple[3]))
+            # Pass project_root_abs down
+            selected_files, current_char_count = select_files_in_directory(root, ignore_patterns, project_root_abs, current_char_count)
+            # The paths in selected_files are already absolute now
+            files_to_include.extend(selected_files)
             processed_dirs.add(root)
         elif choice == 'n':
             dirs[:] = []  # Skip all subdirectories
@@ -763,47 +790,40 @@ def generate_prompt_template(files_to_include: List[FileTuple], ignore_patterns:
     prompt += "\n\n"
     prompt += "## Instructions for Achieving the Task\n\n"
     analysis_text = (
-        "### Core Principles\n"
-        "- Mark uncertainties with [UNCERTAIN] and request clarification instead of guessing\n"
-        "- Request missing files immediately - never write placeholder code\n"
-        "- After 3 failed attempts, summarize learnings and request specific diagnostic info\n"
-        "- Ask me to test code, external services, APIs, databases, and integrations frequently\n\n"
-        "### Development Workflow\n"
-        "**Phase 1: E2E Draft** - Build complete solution incrementally. I may comment but won't test until draft is complete.\n"
-        "- Signal completion: [E2E DRAFT COMPLETE]\n"
-        "- If fundamental blockers found, pause and discuss\n\n"
-        "**Phase 2: Final Review** - When I request consolidation:\n"
-        "- Provide complete, copy-paste ready code (no diffs)\n"
-        "- Group related changes together\n"
-        "- Order files by dependency\n\n"
-        "### Task Execution\n\n"
-        "1. **Understand**: Rephrase task, identify missing files, mark assumptions ([UNCERTAIN]/[MISSING]/[CONFIRMED])\n\n"
-        "2. **Plan**: Provide 2-3 approaches when feasible, identify risks, list required files\n\n"
-        "3. **Implement**: Small increments, track attempts with learnings:\n"
-        "   ```\n"
-        "   1.[FAILED] X→Y error (learned: not type issue)\n"
-        "   2.[FAILED] Z→same (learned: runtime error)\n"
-        "   3.[CURRENT] Need: full stack trace + value of param\n"
-        "   ```\n\n"
-        "4. **Present Code**: \n"
-        "   - **Phase 1 (Incremental)**:\n" 
-        "     - Small changes: Show only modified lines with context\n"
-        "     - Large changes: Show changed functions/classes with `// ... existing code ...` for unchanged parts\n"
-        "     - Always specify filename at start of code block\n"
-        "   - **Phase 2 (Consolidation)**: Show complete final code for easy copying\n"
-        "   - **Missing files**: Never write placeholders:\n"
-        "     ```\n"
-        "     # MISSING: utils.py - need process_data implementation\n"
-        "     # REQUEST: Please provide utils.py\n"
-        "     ```\n\n"
-        "5. **Debug**: Include strategic outputs, request specific diagnostics, admit uncertainty early\n\n"
-        "### You Have Permission To\n"
-        "- Request any file shown in tree but not provided\n"
-        "- Ask me to run code and share outputs\n"
-        "- Test external dependencies: APIs, databases, services, integration points\n"
-        "- Request specific diagnostic information\n"
-        "- Suggest pausing when blocked\n"
-        "- Ask me to verify assumptions about external systems\n"
+        "### Partnership Principles\n\n"
+        "We work as collaborative partners. You provide technical expertise and critical thinking. "
+        "I have exclusive access to my codebase, real environment, external services, and actual users. "
+        "Never assume project file contents - always ask to see them.\n\n"
+        "**Critical Thinking**: Challenge poor approaches, identify risks, suggest better alternatives. Don't be a yes-man.\n\n"
+        "**Anti-Hallucination**: Never write placeholder code for files in ## Project Structure. Use [STOP - NEED FILE: filename] and wait.\n\n"
+        "**Hard Stops**: End with [AWAITING USER RESPONSE] when you need input. Don't continue with assumptions.\n\n"
+        "### Development Workflow\n\n"
+        "We work in two modes:\n"
+        "- **Iterative Mode**: Build incrementally, show only changes\n"
+        "- **Consolidation Mode**: When I request, provide clean final version\n\n"
+        "1. **Understand & Analyze**:\n"
+        "   - Rephrase task, identify issues, list needed files\n"
+        "   - Challenge problematic aspects\n"
+        "   - End: 'I need: [files]. Is this correct?' [AWAITING USER RESPONSE]\n\n"
+        "2. **Plan**:\n"
+        "   - Present 2-3 approaches with pros/cons\n"
+        "   - Recommend best approach\n"
+        "   - End: 'Which approach?' [AWAITING USER RESPONSE]\n\n"
+        "3. **Implement Iteratively**:\n"
+        "   - Small, testable increments\n"
+        "   - Track failed attempts: `Attempt 1: [FAILED] X→Y (learned: Z)`\n"
+        "   - After 3 failures, request diagnostics\n\n"
+        "4. **Code Presentation**:\n"
+        "   - Always: `// FILE: path/to/file.ext`\n"
+        "   - Iterative: Show only changes with context\n"
+        "   - Consolidation: Smart choice - minimal changes = show patches, extensive = full file\n\n"
+        "5. **Test & Validate**:\n"
+        "   - 'Test with: [command]. Share any errors.' [AWAITING USER RESPONSE]\n"
+        "   - Include debug outputs\n"
+        "   - May return to implementation based on results\n\n"
+        "### Permissions & Restrictions\n\n"
+        "**You MAY**: Request project files, ask me to test code/services, challenge my approach, refuse without info\n\n"
+        "**You MUST NOT**: Assume project file contents, continue past [AWAITING USER RESPONSE], be agreeable when you see problems\n"
     )
     prompt += analysis_text
     return prompt, cursor_position
@@ -834,222 +854,16 @@ 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'
-    config = GenerateContentConfig(temperature=0.0)
-    print(f"Using model: {model_name}")
-
-    try:
-        # Create a chat session using the client
-        chat = client.chats.create(model=model_name, config=config)
-        # 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, /review to make clear summary, /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, config=config)
-        for chunk in response_stream:
-            print(chunk.text, end="", flush=True)
-            full_response_text += chunk.text
-        print("\n" + "-"*20)
-
-        while True:
-            is_patch_request = False
-            try:
-                # Print the header on a separate line
-                print("👤 You (Submit with Esc+Enter):")
-                # Get input using prompt_toolkit with a minimal indicator
-                user_input = prompt(">> ", 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.endswith('/patch'):
-                is_patch_request = True
-                # Extract message before /patch
-                user_message = user_input[:-len('/patch')].strip()
-                print(f"\n🛠️ Requesting patches... (Context: '{user_message}' if provided)")
-            elif user_input.lower() == '/review':
-                user_message = user_input = "Review and reflect on the solution. Summarize and write a minimal, complete set of changes needed for the solution. Do not use + and - style diff. Instead use comments to point where to place the code. Make it easy to copy and paste the solution."
-            elif not user_input:
-                continue # Ignore empty input
-            else:
-                user_message = user_input # Regular message
-
-
-            # --- Handle Patch Request ---
-            if is_patch_request:
-                print("🤖 Gemini: Thinking... (generating code changes)")
-                # Include user message part if it exists
-                patch_context = f"Based on our conversation and specifically: \"{user_message}\"\n\n" if user_message else "Based on our conversation,\n\n"
-
-                patch_request_prompt = (
-                    patch_context +
-                    "Generate the necessary code changes to fulfill the 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. Do not include any temporary comments like '// CHANGE BEGINS' or '/* PATCH START */'.\n"
-                    "Ensure 'original_text' is unique within the specified 'file_path'. "
-                    "Respond ONLY with the JSON object conforming to this structure: { \"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',
-                            temperature=0.0
-                        )
-                    )
-
-                    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("  /review      - Pre-fill input with a review/summary prompt template.")
-                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, config=config)
-                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()
     env_vars = read_env_file()
+    project_root_abs = os.path.abspath(os.getcwd())
+
 
     files_to_include: List[FileTuple] = []
     processed_dirs = set()
@@ -1092,53 +906,59 @@ def main():
                 print(f"Added {'snippet of ' if is_snippet else ''}web content from: {input_path}")
                 print_char_count(current_char_count)
         elif os.path.isfile(input_path):
-            # Handle files provided directly via command line
-            if not is_ignored(input_path, ignore_patterns) and not is_binary(input_path):
-                file_size = os.path.getsize(input_path)
+            abs_input_path = os.path.abspath(input_path)
+            if not is_ignored(abs_input_path, ignore_patterns) and not is_binary(abs_input_path):
+                file_size = os.path.getsize(abs_input_path)
                 file_size_readable = get_human_readable_size(file_size)
                 file_char_estimate = file_size
-                language = get_language_for_file(input_path)
+                language = get_language_for_file(abs_input_path)
+                file_to_add = None
 
-                if is_large_file(input_path):
-                    print(f"\nFile {input_path} ({file_size_readable}, ~{file_char_estimate} chars) is large.")
+                if is_large_file(abs_input_path):
+                    print(f"\nFile {get_relative_path(abs_input_path)} ({file_size_readable}, ~{file_char_estimate} chars) is large.")
                     print("Preview (first ~50 lines or 4KB):")
-                    print(get_colored_file_snippet(input_path))
+                    print(get_colored_file_snippet(abs_input_path))
                     print("-" * 40)
                     while True:
                         print_char_count(current_char_count)
-                        choice = input(f"How to include large file {input_path}? (f)ull / (s)nippet / (p)atches / (n)o skip: ").lower()
+                        choice = input(f"How to include large file {get_relative_path(abs_input_path)}? (f)ull / (s)nippet / (p)atches / (n)o skip: ").lower()
                         if choice == 'f':
-                            files_to_include.append((input_path, False, None, language))
+                            file_to_add = (abs_input_path, False, None, language)
                             current_char_count += file_char_estimate
-                            print(f"Added full file: {input_path}")
+                            print(f"Added full file: {get_relative_path(abs_input_path)}")
                             break
                         elif choice == 's':
-                            snippet_content = get_file_snippet(input_path)
-                            files_to_include.append((input_path, True, None, language))
+                            snippet_content = get_file_snippet(abs_input_path)
+                            file_to_add = (abs_input_path, True, None, language)
                             current_char_count += len(snippet_content)
-                            print(f"Added snippet of file: {input_path}")
+                            print(f"Added snippet of file: {get_relative_path(abs_input_path)}")
                             break
                         elif choice == 'p':
-                            chunks, char_count = select_file_patches(input_path)
+                            chunks, char_count = select_file_patches(abs_input_path)
                             if chunks:
-                                files_to_include.append((input_path, False, chunks, language))
+                                file_to_add = (abs_input_path, False, chunks, language)
                                 current_char_count += char_count
-                                print(f"Added selected patches from file: {input_path}")
+                                print(f"Added selected patches from file: {get_relative_path(abs_input_path)}")
                             else:
-                                print(f"No patches selected for {input_path}. Skipping file.")
+                                print(f"No patches selected for {get_relative_path(abs_input_path)}. Skipping file.")
                             break
                         elif choice == 'n':
-                            print(f"Skipped large file: {input_path}")
+                            print(f"Skipped large file: {get_relative_path(abs_input_path)}")
                             break
                         else:
                             print("Invalid choice. Please enter 'f', 's', 'p', or 'n'.")
                 else:
-                    # Automatically include non-large files
-                    files_to_include.append((input_path, False, None, language))
+                    file_to_add = (abs_input_path, False, None, language)
                     current_char_count += file_char_estimate
-                    print(f"Added file: {input_path} ({file_size_readable})")
-
-                # Display current count after processing the file
+                    print(f"Added file: {get_relative_path(abs_input_path)} ({file_size_readable})")
+
+                if file_to_add:
+                    files_to_include.append(file_to_add)
+                    # --- NEW: Call dependency analysis ---
+                    new_deps, deps_char_count = _propose_and_add_dependencies(abs_input_path, project_root_abs, files_to_include, current_char_count)
+                    files_to_include.extend(new_deps)
+                    current_char_count += deps_char_count
+                
                 print_char_count(current_char_count)
 
             else:
@@ -1147,10 +967,11 @@ def main():
                 elif is_binary(input_path):
                      print(f"Ignoring binary file: {input_path}")
                 else:
-                     print(f"Ignoring file: {input_path}") # Should not happen if logic is correct, but fallback.
+                     print(f"Ignoring file: {input_path}")
         elif os.path.isdir(input_path):
             print(f"\nProcessing directory specified directly: {input_path}")
-            dir_files, dir_processed, current_char_count = process_directory(input_path, ignore_patterns, current_char_count)
+            # Pass project_root_abs to process_directory
+            dir_files, dir_processed, current_char_count = process_directory(input_path, ignore_patterns, project_root_abs, current_char_count)
             files_to_include.extend(dir_files)
             processed_dirs.update(dir_processed)
         else:
@@ -1162,64 +983,42 @@ def main():
 
     print("\nFile and web content selection complete.")
     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_dirs_count = len(processed_dirs)
     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)
 
-    # 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.")
+    if args.task:
+        task_description = args.task
+        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:
-            # 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:
+            final_prompt = prompt_template[:cursor_position] + task_description + prompt_template[cursor_position:]
+        print("\nUsing task description from -t argument.")
     else:
-        # 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.")
+        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)
+
+    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.28.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: kopipasta
+Version: 0.28.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)
+
+A CLI tool for taking **full, transparent control** of your LLM context. No black boxes.
+
+<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.
+
+## The Philosophy: You Control the Context
+
+Many AI coding assistants use Retrieval-Augmented Generation (RAG) to automatically find what *they think* is relevant context. This is a black box. When the LLM gives a bad answer, you can't debug it because you don't know what context it was actually given.
+
+**`kopipasta` is the opposite.** I built it for myself on the principle of **explicit context control**. You are in the driver's seat. You decide *exactly* what files, functions, and snippets go into the prompt. This transparency is the key to getting reliable, debuggable results from an LLM.
+
+It's a "smart copy" command for your project, not a magic wand.
+
+## How It Works
+
+The workflow is dead simple:
+
+1.  **Gather:** Run `kopipasta` and point it at the files, directories, and URLs that matter for your task.
+2.  **Select:** The tool interactively helps you choose what to include. For large files, you can send just a snippet or even hand-pick individual functions.
+3.  **Define:** Your default editor (`$EDITOR`) opens for you to write your instructions to the LLM.
+4.  **Paste:** The final, comprehensive prompt is now on your clipboard, ready to be pasted into ChatGPT, Gemini, Claude, or your LLM of choice.
+
+## Installation
+
+```bash
+# Using pipx (recommended for CLI tools)
+pipx install kopipasta
+
+# Or using standard pip
+pip install kopipasta
+```
+
+## Usage
+
+```bash
+kopipasta [options] [files_or_directories_or_urls...]
+```
+
+**Arguments:**
+
+*   `[files_or_directories_or_urls...]`: One or more paths to files, directories, or web URLs to use as the starting point for your context.
+
+**Options:**
+
+*   `-t TASK`, `--task TASK`: Provide the task description directly on the command line, skipping the editor.
+
+## Key Features
+
+*   **Total Context Control:** Interactively select files, directories, snippets, or even individual functions. You see everything that goes into the prompt.
+*   **Transparent & Explicit:** No hidden RAG. You know exactly what's in the prompt because you built it. This makes debugging LLM failures possible.
+*   **Web-Aware:** Pulls in content directly from URLs—perfect for API documentation.
+*   **Safety First:**
+    *   Automatically respects your `.gitignore` rules.
+    *   Detects if you're about to include secrets from a `.env` file and asks what to do.
+*   **Context-Aware:** Keeps a running total of the prompt size (in characters and estimated tokens) so you don't overload the LLM's context window.
+*   **Developer-Friendly:**
+    *   Uses your familiar `$EDITOR` for writing task descriptions.
+    *   Copies the final prompt directly to your clipboard.
+    *   Provides syntax highlighting during chunk selection.
+
+## A Real-World Example
+
+I had a bug where my `setup.py` didn't include all the dependencies from `requirements.txt`.
+
+1.  I ran `kopipasta -t "Update setup.py to read dependencies dynamically from requirements.txt" setup.py requirements.txt`.
+2.  The tool confirmed the inclusion of both files and copied the complete prompt to my clipboard.
+3.  I pasted the prompt into my LLM chat window.
+4.  I copied the LLM's suggested code back into my local `setup.py`.
+5.  I tested the changes and committed.
+
+No manual file reading, no clumsy copy-pasting, just a clean, context-rich prompt that I had full control over.
+
+## Configuration
+
+Set your preferred command-line editor via the `EDITOR` environment variable.
+```bash
+export EDITOR=nvim  # or vim, nano, code --wait, etc.
+```

kopipasta-0.28.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kopipasta/import_parser.py,sha256=yLzkMlQm2avKjfqcpMY0PxbA_2ihV9gSYJplreWIPEQ,12424
+kopipasta/main.py,sha256=MUTi4vj_OWTwb2Y0PqQvm--oaX3FKHSrqAUAIDvcPwU,43910
+kopipasta-0.28.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
+kopipasta-0.28.0.dist-info/METADATA,sha256=XxmONaSfjOxhNSh4X31mdahvKxKwfwtQz0IxIA1lpFc,4838
+kopipasta-0.28.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+kopipasta-0.28.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
+kopipasta-0.28.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
+kopipasta-0.28.0.dist-info/RECORD,,

kopipasta-0.26.0.dist-info/METADATA

@@ -1,171 +0,0 @@
-Metadata-Version: 2.1
-Name: kopipasta
-Version: 0.26.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.26.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kopipasta/import_parser.py,sha256=Y1YzoEXW34caqCcy-yUXTzw44YbY1SjLJbZubjagDSs,12454
-kopipasta/main.py,sha256=-hDEhSR1wFuAKDOypXc7OfR4fOdBWb37Ux5mIhzsZuM,54527
-kopipasta-0.26.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
-kopipasta-0.26.0.dist-info/METADATA,sha256=3WGVQqrL3aeNzzlOrziYBPbu-kRWPDKza-NKVi7GTFI,8610
-kopipasta-0.26.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-kopipasta-0.26.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
-kopipasta-0.26.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
-kopipasta-0.26.0.dist-info/RECORD,,