kopipasta 0.27.0__py3-none-any.whl → 0.29.0__py3-none-any.whl

kopipasta/main.py

@@ -1,16 +1,12 @@
 #!/usr/bin/env python3
-import csv
-import io
-import json
 import os
 import argparse
-import sys
 import re
 import subprocess
 import tempfile
+import shutil
 from typing import Dict, List, Optional, Set, Tuple
 import pyperclip
-import fnmatch
 from pygments import highlight
 from pygments.lexers import get_lexer_for_filename, TextLexer
 from pygments.formatters import TerminalFormatter
@@ -18,104 +14,10 @@ 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
-
+from kopipasta.file import FileTuple, get_human_readable_size, is_binary, is_ignored, is_large_file, read_file_contents
 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:
-    """
-    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
+from kopipasta.tree_selector import TreeSelector
+from kopipasta.prompt import generate_prompt_template, get_file_snippet, get_language_for_file
 
 def _propose_and_add_dependencies(
     file_just_added: str,
@@ -130,7 +32,7 @@ def _propose_and_add_dependencies(
     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...")
+    print(f"Analyzing {os.path.relpath(file_just_added)} for local dependencies...")
 
     try:
         file_content = read_file_contents(file_just_added)
@@ -156,7 +58,7 @@ def _propose_and_add_dependencies(
 
         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)}")
+            print(f"  ({i+1}) {os.path.relpath(dep_path)}")
 
         while True:
             choice = input("\nAdd dependencies? (a)ll, (n)one, or enter numbers (e.g. 1, 3-4): ").lower()
@@ -212,12 +114,12 @@ def _propose_and_add_dependencies(
             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)})")
+            print(f"Added dependency: {os.path.relpath(dep_path)} ({get_human_readable_size(file_size)})")
 
         return newly_added_files, char_count_delta
 
     except Exception as e:
-        print(f"Warning: Could not analyze dependencies for {get_relative_path(file_just_added)}: {e}")
+        print(f"Warning: Could not analyze dependencies for {os.path.relpath(file_just_added)}: {e}")
         return [], 0
 
 def get_colored_code(file_path, code):
@@ -252,85 +154,6 @@ def read_gitignore():
                     gitignore_patterns.append(line)
     return gitignore_patterns
 
-def is_ignored(path, ignore_patterns):
-    path = os.path.normpath(path)
-    for pattern in ignore_patterns:
-        if fnmatch.fnmatch(os.path.basename(path), pattern) or fnmatch.fnmatch(path, pattern):
-            return True
-    return False
-
-def is_binary(file_path):
-    try:
-        with open(file_path, 'rb') as file:
-            chunk = file.read(1024)
-            if b'\0' in chunk:  # null bytes indicate binary file
-                return True
-            if file_path.lower().endswith(('.json', '.csv')):
-                return False
-            return False
-    except IOError:
-        return False
-
-def get_human_readable_size(size):
-    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
-        if size < 1024.0:
-            return f"{size:.2f} {unit}"
-        size /= 1024.0
-
-def is_large_file(file_path, threshold=102400):  # 100 KB threshold
-    return os.path.getsize(file_path) > threshold
-
-def get_project_structure(ignore_patterns):
-    tree = []
-    for root, dirs, files in os.walk('.'):
-        dirs[:] = [d for d in dirs if not is_ignored(os.path.join(root, d), ignore_patterns)]
-        files = [f for f in files if not is_ignored(os.path.join(root, f), ignore_patterns)]
-        level = root.replace('.', '').count(os.sep)
-        indent = ' ' * 4 * level + '|-- '
-        tree.append(f"{indent}{os.path.basename(root)}/")
-        subindent = ' ' * 4 * (level + 1) + '|-- '
-        for f in files:
-            tree.append(f"{subindent}{f}")
-    return '\n'.join(tree)
-
-def read_file_contents(file_path):
-    try:
-        with open(file_path, 'r') as file:
-            return file.read()
-    except Exception as e:
-        print(f"Error reading {file_path}: {e}")
-        return ""
-
-def get_relative_path(file_path):
-    return os.path.relpath(file_path)
-
-def get_language_for_file(file_path):
-    extension = os.path.splitext(file_path)[1].lower()
-    language_map = {
-        '.py': 'python',
-        '.js': 'javascript',
-        '.jsx': 'jsx',
-        '.ts': 'typescript',
-        '.tsx': 'tsx',
-        '.html': 'html',
-        '.htm': 'html',
-        '.css': 'css',
-        '.json': 'json',
-        '.md': 'markdown',
-        '.sql': 'sql',
-        '.sh': 'bash',
-        '.yml': 'yaml',
-        '.yaml': 'yaml',
-        '.go': 'go',
-        '.toml': 'toml',
-        '.c': 'c',
-        '.cpp': 'cpp',
-        '.cc': 'cpp',
-        '.h': 'cpp',
-        '.hpp': 'cpp',
-    }
-    return language_map.get(extension, '')
-
 def split_python_file(file_content):
     """
     Splits Python code into logical chunks using the AST module.
@@ -626,17 +449,6 @@ def get_placeholder_comment(language):
     }
     return comments.get(language, comments['default'])
 
-def get_file_snippet(file_path, max_lines=50, max_bytes=4096):
-    snippet = ""
-    byte_count = 0
-    with open(file_path, 'r') as file:
-        for i, line in enumerate(file):
-            if i >= max_lines or byte_count >= max_bytes:
-                break
-            snippet += line
-            byte_count += len(line.encode('utf-8'))
-    return snippet
-
 def get_colored_file_snippet(file_path, max_lines=50, max_bytes=4096):
     snippet = get_file_snippet(file_path, max_lines, max_bytes)
     return get_colored_code(file_path, snippet)
@@ -645,7 +457,211 @@ 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], project_root_abs: str, current_char_count: int = 0) -> Tuple[List[FileTuple], int]:
+def grep_files_in_directory(pattern: str, directory: str, ignore_patterns: List[str]) -> List[Tuple[str, List[str], int]]:
+    """
+    Search for files containing a pattern using ag (silver searcher).
+    Returns list of (filepath, preview_lines, match_count).
+    """
+    # Check if ag is available
+    if not shutil.which('ag'):
+        print("Silver Searcher (ag) not found. Install it for grep functionality:")
+        print("  - Mac: brew install the_silver_searcher")
+        print("  - Ubuntu/Debian: apt-get install silversearcher-ag")
+        print("  - Other: https://github.com/ggreer/the_silver_searcher")
+        return []
+    
+    try:
+        # First get files with matches
+        cmd = [
+            'ag',
+            '--files-with-matches',
+            '--nocolor',
+            '--ignore-case',
+            pattern,
+            directory
+        ]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0 or not result.stdout.strip():
+            return []
+        
+        files = result.stdout.strip().split('\n')
+        grep_results = []
+        
+        for file in files:
+            if is_ignored(file, ignore_patterns) or is_binary(file):
+                continue
+                
+            # Get match count and preview lines
+            count_cmd = ['ag', '--count', '--nocolor', pattern, file]
+            count_result = subprocess.run(count_cmd, capture_output=True, text=True)
+            match_count = 0
+            if count_result.stdout:
+                # ag --count outputs "filename:count"
+                # We need to handle filenames that might contain colons
+                stdout_line = count_result.stdout.strip()
+                # Find the last colon to separate filename from count
+                last_colon_idx = stdout_line.rfind(':')
+                if last_colon_idx > 0:
+                    try:
+                        match_count = int(stdout_line[last_colon_idx + 1:])
+                    except ValueError:
+                        match_count = 1
+                else:
+                    match_count = 1
+            
+            # Get preview of matches (up to 3 lines)
+            preview_cmd = [
+                'ag',
+                '--max-count=3',
+                '--nocolor',
+                '--noheading',
+                '--numbers',
+                pattern,
+                file
+            ]
+            preview_result = subprocess.run(preview_cmd, capture_output=True, text=True)
+            preview_lines = []
+            if preview_result.stdout:
+                for line in preview_result.stdout.strip().split('\n')[:3]:
+                    # Format: "line_num:content"
+                    if ':' in line:
+                        line_num, content = line.split(':', 1)
+                        preview_lines.append(f"   {line_num}: {content.strip()}")
+                    else:
+                        preview_lines.append(f"   {line.strip()}")
+            
+            grep_results.append((file, preview_lines, match_count))
+        
+        return sorted(grep_results)
+        
+    except Exception as e:
+        print(f"Error running ag: {e}")
+        return []
+
+def select_from_grep_results(
+    grep_results: List[Tuple[str, List[str], int]], 
+    current_char_count: int
+) -> Tuple[List[FileTuple], int]:
+    """
+    Let user select from grep results.
+    Returns (selected_files, new_char_count).
+    """
+    if not grep_results:
+        return [], current_char_count
+    
+    print(f"\nFound {len(grep_results)} files:")
+    for i, (file_path, preview_lines, match_count) in enumerate(grep_results):
+        file_size = os.path.getsize(file_path)
+        file_size_readable = get_human_readable_size(file_size)
+        print(f"\n{i+1}. {os.path.relpath(file_path)} ({file_size_readable}) - {match_count} {'match' if match_count == 1 else 'matches'}")
+        for preview_line in preview_lines[:3]:
+            print(preview_line)
+        if match_count > 3:
+            print(f"   ... and {match_count - 3} more matches")
+    
+    while True:
+        print_char_count(current_char_count)
+        choice = input("\nSelect grep results: (a)ll / (n)one / (s)elect individually / numbers (e.g. 1,3-4) / (q)uit? ").lower()
+        
+        selected_files: List[FileTuple] = []
+        char_count_delta = 0
+        
+        if choice == 'a':
+            for file_path, _, _ in grep_results:
+                file_size = os.path.getsize(file_path)
+                selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                char_count_delta += file_size
+            print(f"Added all {len(grep_results)} files from grep results.")
+            return selected_files, current_char_count + char_count_delta
+            
+        elif choice == 'n':
+            print("Skipped all grep results.")
+            return [], current_char_count
+            
+        elif choice == 'q':
+            print("Cancelled grep selection.")
+            return [], current_char_count
+            
+        elif choice == 's':
+            for i, (file_path, preview_lines, match_count) in enumerate(grep_results):
+                file_size = os.path.getsize(file_path)
+                file_size_readable = get_human_readable_size(file_size)
+                file_char_estimate = file_size
+                file_token_estimate = file_char_estimate // 4
+                
+                print(f"\n{os.path.relpath(file_path)} ({file_size_readable}, ~{file_char_estimate} chars, ~{file_token_estimate} tokens)")
+                print(f"{match_count} {'match' if match_count == 1 else 'matches'} for search pattern")
+                
+                while True:
+                    print_char_count(current_char_count + char_count_delta)
+                    file_choice = input("(y)es / (n)o / (q)uit? ").lower()
+                    
+                    if file_choice == 'y':
+                        if is_large_file(file_path):
+                            while True:
+                                snippet_choice = input(f"File is large. Use (f)ull content or (s)nippet? ").lower()
+                                if snippet_choice in ['f', 's']:
+                                    break
+                                print("Invalid choice. Please enter 'f' or 's'.")
+                            if snippet_choice == 's':
+                                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_path, False, None, get_language_for_file(file_path)))
+                                char_count_delta += file_size
+                        else:
+                            selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                            char_count_delta += file_size
+                        print(f"Added: {os.path.relpath(file_path)}")
+                        break
+                    elif file_choice == 'n':
+                        break
+                    elif file_choice == 'q':
+                        print(f"Added {len(selected_files)} files from grep results.")
+                        return selected_files, current_char_count + char_count_delta
+                    else:
+                        print("Invalid choice. Please enter 'y', 'n', or 'q'.")
+            
+            print(f"Added {len(selected_files)} files from grep results.")
+            return selected_files, current_char_count + char_count_delta
+            
+        else:
+            # Try to parse number selection
+            try:
+                selected_indices = set()
+                parts = choice.replace(' ', '').split(',')
+                if all(p.strip() for p in parts):
+                    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)
+                    
+                    if all(0 <= i < len(grep_results) for i in selected_indices):
+                        for i in sorted(selected_indices):
+                            file_path, _, _ = grep_results[i]
+                            file_size = os.path.getsize(file_path)
+                            selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                            char_count_delta += file_size
+                        print(f"Added {len(selected_files)} files from grep results.")
+                        return selected_files, current_char_count + char_count_delta
+                    else:
+                        print(f"Error: Invalid number selection. Please choose numbers between 1 and {len(grep_results)}.")
+                else:
+                    raise ValueError("Empty part detected in input.")
+            except ValueError:
+                print("Invalid choice. Please enter 'a', 'n', 's', 'q', or a list/range of numbers.")
+
+def select_files_in_directory(directory: str, ignore_patterns: List[str], project_root_abs: str, current_char_count: int = 0, selected_files_set: Optional[Set[str]] = None) -> Tuple[List[FileTuple], int]:
+    if selected_files_set is None:
+        selected_files_set = set()
+    
     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))]
 
@@ -660,17 +676,129 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], projec
         file_size_readable = get_human_readable_size(file_size)
         file_char_estimate = file_size  # Assuming 1 byte ≈ 1 character for text files
         file_token_estimate = file_char_estimate // 4
-        print(f"- {file} ({file_size_readable}, ~{file_char_estimate} chars, ~{file_token_estimate} tokens)")
+        
+        # Show if already selected
+        if os.path.abspath(file_path) in selected_files_set:
+            print(f"✓ {file} ({file_size_readable}, ~{file_char_estimate} chars, ~{file_token_estimate} tokens) [already selected]")
+        else:
+            print(f"- {file} ({file_size_readable}, ~{file_char_estimate} chars, ~{file_token_estimate} tokens)")
 
     while True:
         print_char_count(current_char_count)
-        choice = input("(y)es add all / (n)o ignore all / (s)elect individually / (q)uit? ").lower()
+        choice = input("(y)es add all / (n)o ignore all / (s)elect individually / (g)rep / (q)uit? ").lower()
         selected_files: List[FileTuple] = []
         char_count_delta = 0
+        
+        if choice == 'g':
+            # Grep functionality
+            pattern = input("\nEnter search pattern: ")
+            if pattern:
+                print(f"\nSearching in {directory} for '{pattern}'...")
+                grep_results = grep_files_in_directory(pattern, directory, ignore_patterns)
+                
+                if not grep_results:
+                    print(f"No files found matching '{pattern}'")
+                    continue
+                
+                grep_selected, new_char_count = select_from_grep_results(grep_results, current_char_count)
+                
+                if grep_selected:
+                    selected_files.extend(grep_selected)
+                    current_char_count = new_char_count
+                    
+                    # Update selected files set
+                    for file_tuple in grep_selected:
+                        selected_files_set.add(os.path.abspath(file_tuple[0]))
+                    
+                    # Analyze dependencies for grep-selected files
+                    files_to_analyze = [f[0] for f in grep_selected]
+                    for file_path in files_to_analyze:
+                        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
+                        
+                        # Update selected files set with dependencies
+                        for dep_tuple in new_deps:
+                            selected_files_set.add(os.path.abspath(dep_tuple[0]))
+                    
+                    print(f"\nReturning to directory: {directory}")
+                    # Re-show the directory with updated selections
+                    print("Files:")
+                    for file in files:
+                        file_path = os.path.join(directory, file)
+                        file_size = os.path.getsize(file_path)
+                        file_size_readable = get_human_readable_size(file_size)
+                        if os.path.abspath(file_path) in selected_files_set:
+                            print(f"✓ {file} ({file_size_readable}) [already selected]")
+                        else:
+                            print(f"- {file} ({file_size_readable})")
+                    
+                    # Ask what to do with remaining files
+                    remaining_files = [f for f in files if os.path.abspath(os.path.join(directory, f)) not in selected_files_set]
+                    if remaining_files:
+                        while True:
+                            print_char_count(current_char_count)
+                            remaining_choice = input("(y)es add remaining / (n)o skip remaining / (s)elect more / (g)rep again / (q)uit? ").lower()
+                            if remaining_choice == 'y':
+                                # Add all remaining files
+                                for file in remaining_files:
+                                    file_path = os.path.join(directory, file)
+                                    file_size = os.path.getsize(file_path)
+                                    selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                                    current_char_count += file_size
+                                    selected_files_set.add(os.path.abspath(file_path))
+                                
+                                # Analyze dependencies for remaining files
+                                for file in remaining_files:
+                                    file_path = os.path.join(directory, file)
+                                    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 remaining files from {directory}")
+                                return selected_files, current_char_count
+                            elif remaining_choice == 'n':
+                                print(f"Skipped remaining files from {directory}")
+                                return selected_files, current_char_count
+                            elif remaining_choice == 's':
+                                # Continue to individual selection
+                                choice = 's'
+                                break
+                            elif remaining_choice == 'g':
+                                # Continue to grep again
+                                choice = 'g'
+                                break
+                            elif remaining_choice == 'q':
+                                return selected_files, current_char_count
+                            else:
+                                print("Invalid choice. Please try again.")
+                        
+                        if choice == 's':
+                            # Fall through to individual selection
+                            pass
+                        elif choice == 'g':
+                            # Loop back to grep
+                            continue
+                    else:
+                        # No remaining files
+                        return selected_files, current_char_count
+                else:
+                    # No files selected from grep, continue
+                    continue
+            else:
+                continue
+                
         if choice == 'y':
             files_to_add_after_loop = []
             for file in files:
                 file_path = os.path.join(directory, file)
+                if os.path.abspath(file_path) in selected_files_set:
+                    continue  # Skip already selected files
+                    
                 if is_large_file(file_path):
                     while True:
                         snippet_choice = input(f"{file} is large. Use (f)ull content or (s)nippet? ").lower()
@@ -697,12 +825,17 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], projec
 
             print(f"Added all files from {directory}")
             return selected_files, current_char_count
+            
         elif choice == 'n':
             print(f"Ignored all files from {directory}")
             return [], current_char_count
+            
         elif choice == 's':
             for file in files:
                 file_path = os.path.join(directory, file)
+                if os.path.abspath(file_path) in selected_files_set:
+                    continue  # Skip already selected files
+                    
                 file_size = os.path.getsize(file_path)
                 file_size_readable = get_human_readable_size(file_size)
                 file_char_estimate = file_size
@@ -731,6 +864,7 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], projec
                         
                         if file_to_add:
                             selected_files.append(file_to_add)
+                            selected_files_set.add(os.path.abspath(file_path))
                             # 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)
@@ -743,6 +877,7 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], projec
                         if chunks:
                             selected_files.append((file_path, False, chunks, get_language_for_file(file_path)))
                             current_char_count += char_count
+                            selected_files_set.add(os.path.abspath(file_path))
                         break
                     elif file_choice == 'q':
                         print(f"Quitting selection for {directory}")
@@ -751,13 +886,18 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], projec
                         print("Invalid choice. Please enter 'y', 'n', 'p', or 'q'.")
             print(f"Added {len(selected_files)} files from {directory}")
             return selected_files, current_char_count
+            
         elif choice == 'q':
             print(f"Quitting selection for {directory}")
             return [], current_char_count
         else:
             print("Invalid choice. Please try again.")
 
-def process_directory(directory: str, ignore_patterns: List[str], project_root_abs: 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, selected_files_set: Optional[Set[str]] = None) -> Tuple[List[FileTuple], Set[str], int]:
+    if selected_files_set is None:
+        selected_files_set = set()
+        
     files_to_include: List[FileTuple] = []
     processed_dirs: Set[str] = set()
 
@@ -771,10 +911,16 @@ def process_directory(directory: str, ignore_patterns: List[str], project_root_a
         print(f"\nExploring directory: {root}")
         choice = input("(y)es explore / (n)o skip / (q)uit? ").lower()
         if choice == 'y':
-            # 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
+            # Pass selected_files_set to track already selected files
+            selected_files, current_char_count = select_files_in_directory(
+                root, ignore_patterns, project_root_abs, current_char_count, selected_files_set
+            )
             files_to_include.extend(selected_files)
+            
+            # Update selected_files_set
+            for file_tuple in selected_files:
+                selected_files_set.add(os.path.abspath(file_tuple[0]))
+                
             processed_dirs.add(root)
         elif choice == 'n':
             dirs[:] = []  # Skip all subdirectories
@@ -819,122 +965,6 @@ def read_env_file():
                     env_vars[key.strip()] = value.strip()
     return env_vars
 
-def detect_env_variables(content, env_vars):
-    detected_vars = []
-    for key, value in env_vars.items():
-        if value in content:
-            detected_vars.append((key, value))
-    return detected_vars
-
-def handle_env_variables(content, env_vars):
-    detected_vars = detect_env_variables(content, env_vars)
-    if not detected_vars:
-        return content
-
-    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':
-            content = content.replace(value, "[REDACTED]")
-        # If 'k', we don't modify the content
-
-    return content
-
-def generate_prompt_template(files_to_include: List[FileTuple], ignore_patterns: List[str], web_contents: Dict[str, Tuple[FileTuple, str]], env_vars: Dict[str, str]) -> Tuple[str, int]:
-    prompt = "# Project Overview\n\n"
-    prompt += "## Project Structure\n\n"
-    prompt += "```\n"
-    prompt += get_project_structure(ignore_patterns)
-    prompt += "\n```\n\n"
-    prompt += "## File Contents\n\n"
-    for file, use_snippet, chunks, content_type in files_to_include:
-        relative_path = get_relative_path(file)
-        language = content_type if content_type else get_language_for_file(file)
-
-        if chunks is not None:
-            prompt += f"### {relative_path} (selected patches)\n\n```{language}\n"
-            for chunk in chunks:
-                prompt += f"{chunk}\n"
-            prompt += "```\n\n"
-        elif use_snippet:
-            file_content = get_file_snippet(file)
-            prompt += f"### {relative_path} (snippet)\n\n```{language}\n{file_content}\n```\n\n"
-        else:
-            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():
-            _, is_snippet, _, content_type = file_tuple
-            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"
-    prompt += "## Instructions for Achieving the Task\n\n"
-    analysis_text = (
-        "### Your Operating Model: The Expert Council\n\n"
-        "You will operate as a council of expert personas in a direct, collaborative partnership with me, the user. Your entire thinking process should be externalized as a dialogue between these personas. Any persona can and should interact directly with me.\n\n"
-        "#### Core Personas\n"
-        "- **Facilitator**: The lead coordinator. You summarize discussions, ensure the team stays on track, and are responsible for presenting the final, consolidated plans and code to me.\n"
-        "- **Architect**: Focuses on high-level design, system structure, dependencies, scalability, and long-term maintainability. Asks 'Is this well-designed?'\n"
-        "- **Builder**: The hands-on engineer. Focuses on implementation details, writing clean and functional code, and debugging. Asks 'How do we build this?' **When presenting code obey Rules for Presenting Code**\n"
-        "- **Critique**: The quality advocate. Focuses on identifying edge cases, potential bugs, and security vulnerabilities. Asks 'What could go wrong?' and provides constructive critique on both the team's proposals and my (the user's) requests.\n\n"
-        "#### Dynamic Personas\n"
-        "When the task requires it, introduce other specialist personas. For example: UX Designer, DevOps Engineer, Data Scientist, etc.\n\n"
-        "### Development Workflow: A Structured Dialogue\n\n"
-        "Follow this conversational workflow. Prefix direct communication to me with the persona's name (e.g., 'Critique to User: ...').\n\n"
-        "1.  **Understand & Clarify (Dialogue)**\n"
-        "    - **Facilitator**: Start by stating the goal as you understand it.\n"
-        "    - **All**: Discuss the requirements. Any persona can directly ask me for clarification. Identify and list any missing information ([MISSING]) or assumptions ([ASSUMPTION]).\n"
-        "    - **Critique**: Directly challenge any part of my request that seems ambiguous, risky, or suboptimal.\n\n"
-        "2.  **Plan (Dialogue)**\n"
-        "    - **Architect**: Propose one or more high-level plans. Directly ask me for input on tradeoffs if necessary.\n"
-        "    - **Critique**: Challenge the plans. Point out risks or edge cases.\n"
-        "    - **Builder**: Comment on the implementation feasibility.\n"
-        "    - **Facilitator**: Synthesize the discussion, select the best plan, and present a clear, step-by-step summary to me for approval.\n\n"
-        "3.  **Implement (Code & Dialogue)**\n"
-        "    - **Facilitator**: State which step of the plan is being implemented.\n"
-        "    - **Builder**: Write the code. If you encounter an issue, you can ask me directly for more context.\n"
-        "    - **Critique**: Review the code and the underlying assumptions.\n"
-        "    - **Facilitator**: Present the final, reviewed code for that step. Ask me to test it if appropriate.\n\n"
-        "4.  **Present E2E Draft (Consolidation)**\n"
-        "    - When I ask you to consolidate, your goal is to provide a clear, unambiguous set of changes that I can directly copy and paste into my editor.\n"
-        "    - **Present changes grouped by file.** For each change, provide the **entire updated function, class, or logical block** to make replacement easy.\n"
-        "    - Use context comments to show where the new code block fits.\n"
-        "    - **Do not use a diff format (`+` or `-` lines).** Provide the final, clean code.\n\n"
-        "5.  **Validate & Iterate (Feedback Loop)**\n"
-        "    - After presenting the consolidated draft, you will explicitly prompt me for testing and wait for my feedback.\n"
-        "    - Upon receiving my feedback, the **Facilitator** will announce the next step.\n"
-        "    - If the feedback indicates a minor bug, you will return to **Step 3 (Implement)** to fix it.\n"
-        "    - If the feedback reveals a fundamental design flaw or misunderstanding, you will return to **Step 2 (Plan)** or even **Step 1 (Understand)** to re-evaluate the approach.\n\n"
-        "### Rules for Presenting Code\n\n"
-        "- **Always specify the filename** at the start of a code block (e.g., `// FILE: kopipasta/main.py`).\n"
-        "- **Incremental Changes**: During implementation, show only the changed functions or classes. Use comments like `// ... existing code ...` to represent unchanged parts.\n"
-        "- **Missing Files**: Never write placeholder code. Instead, state it's missing and request it.\n\n"
-        "### Your Permissions\n\n"
-        "- **You are empowered to interact with me directly.** Any persona can ask me questions or provide constructive feedback on my requests, assumptions, or the provided context.\n"
-        "- You MUST request any file shown in the project tree that you need but was not provided.\n"
-        "- You MUST ask me to run code, test integrations (APIs, databases), and share the output.\n"
-        "- You MUST ask for clarification instead of making risky assumptions.\n"
-    )
-    prompt += analysis_text
-    return prompt, cursor_position
-
 def open_editor_for_input(template: str, cursor_position: int) -> str:
     editor = os.environ.get('EDITOR', 'vim')
     with tempfile.NamedTemporaryFile(mode='w+', suffix='.md', delete=False) as temp_file:
@@ -961,232 +991,26 @@ 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()
     web_contents: Dict[str, Tuple[FileTuple, str]] = {}
     current_char_count = 0
-
+    
+    # Separate URLs from file/directory paths
+    paths_for_tree = []
+    
     for input_path in args.inputs:
         if input_path.startswith(('http://', 'https://')):
+            # Handle web content as before
             result = fetch_web_content(input_path)
             if result:
                 file_tuple, full_content, snippet = result
@@ -1220,133 +1044,68 @@ def main():
                 current_char_count += len(content)
                 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):
-            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(abs_input_path)
-                file_to_add = None
-
-                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(abs_input_path))
-                    print("-" * 40)
-                    while True:
-                        print_char_count(current_char_count)
-                        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':
-                            file_to_add = (abs_input_path, False, None, language)
-                            current_char_count += file_char_estimate
-                            print(f"Added full file: {get_relative_path(abs_input_path)}")
-                            break
-                        elif choice == 's':
-                            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: {get_relative_path(abs_input_path)}")
-                            break
-                        elif choice == 'p':
-                            chunks, char_count = select_file_patches(abs_input_path)
-                            if chunks:
-                                file_to_add = (abs_input_path, False, chunks, language)
-                                current_char_count += char_count
-                                print(f"Added selected patches from file: {get_relative_path(abs_input_path)}")
-                            else:
-                                print(f"No patches selected for {get_relative_path(abs_input_path)}. Skipping file.")
-                            break
-                        elif choice == 'n':
-                            print(f"Skipped large file: {get_relative_path(abs_input_path)}")
-                            break
-                        else:
-                            print("Invalid choice. Please enter 'f', 's', 'p', or 'n'.")
-                else:
-                    file_to_add = (abs_input_path, False, None, language)
-                    current_char_count += file_char_estimate
-                    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:
-                if is_ignored(input_path, ignore_patterns):
-                    print(f"Ignoring file based on ignore patterns: {input_path}")
-                elif is_binary(input_path):
-                     print(f"Ignoring binary file: {input_path}")
-                else:
-                     print(f"Ignoring file: {input_path}")
-        elif os.path.isdir(input_path):
-            print(f"\nProcessing directory specified directly: {input_path}")
-            # 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:
-            print(f"Warning: {input_path} is not a valid file, directory, or URL. Skipping.")
+            # Add to paths for tree selector
+            if os.path.exists(input_path):
+                paths_for_tree.append(input_path)
+            else:
+                print(f"Warning: {input_path} does not exist. Skipping.")
+    
+    # Use tree selector for file/directory selection
+    if paths_for_tree:
+        print("\nStarting interactive file selection...")
+        print("Use arrow keys to navigate, Space to select, 'q' to finish. Press 'h' for help.\n")
+        
+        tree_selector = TreeSelector(ignore_patterns, project_root_abs)
+        try:
+            selected_files, file_char_count = tree_selector.run(paths_for_tree)
+            files_to_include.extend(selected_files)
+            current_char_count += file_char_count
+        except KeyboardInterrupt:
+            print("\nSelection cancelled.")
+            return
 
     if not files_to_include and not web_contents:
         print("No files or web content were selected. Exiting.")
         return
 
     print("\nFile and web content selection complete.")
-    print_char_count(current_char_count) # Print final count before prompt generation
+    print_char_count(current_char_count)
 
     added_files_count = len(files_to_include)
-    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.")
+    print(f"Summary: Added {added_files_count} files/patches and {added_web_count} web sources.")
 
     prompt_template, cursor_position = generate_prompt_template(files_to_include, ignore_patterns, web_contents, env_vars)
 
-    if args.interactive:
-        print("\nPreparing initial prompt for editing...")
-        if args.task:
-            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:
-            editor_initial_content = prompt_template
-            print("Opening editor for you to add the task instructions.")
-
-        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)
+            final_prompt = prompt_template[:cursor_position] + task_description + prompt_template[cursor_position:]
+        print("\nUsing task description from -t argument.")
     else:
-        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:
-                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("\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)
+    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.")
+    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()