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

kopipasta/main.py

@@ -1,14 +1,12 @@
 #!/usr/bin/env python3
-import csv
-import io
 import os
 import argparse
 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
@@ -16,9 +14,10 @@ import pygments.util
 
 import requests
 
+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]
+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,
@@ -33,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)
@@ -59,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()
@@ -115,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):
@@ -155,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.
@@ -529,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)
@@ -548,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))]
 
@@ -563,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()
@@ -600,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
@@ -634,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)
@@ -646,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}")
@@ -654,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()
 
@@ -674,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
@@ -722,112 +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 = (
-        "### 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
-
 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:
@@ -864,14 +1001,16 @@ def main():
     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
@@ -905,89 +1044,37 @@ 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)