kopipasta 0.30.0__tar.gz → 0.32.0__tar.gz

{kopipasta-0.30.0/kopipasta.egg-info → kopipasta-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.30.0
+Version: 0.32.0
 Summary: A CLI tool to generate prompts with project structure and file contents
 Home-page: https://github.com/mkorpela/kopipasta
 Author: Mikko Korpela

kopipasta-0.32.0/kopipasta/cache.py

@@ -0,0 +1,37 @@
+import json
+import os
+from pathlib import Path
+from typing import List, Tuple
+
+# Define FileTuple for type hinting
+FileTuple = Tuple[str, bool, List[str] | None, str]
+
+def get_cache_file_path() -> Path:
+    """Gets the cross-platform path to the cache file for the last selection."""
+    cache_dir = Path.home() / ".cache" / "kopipasta"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir / "last_selection.json"
+
+def save_selection_to_cache(files_to_include: List[FileTuple]):
+    """Saves the list of selected file relative paths to the cache."""
+    cache_file = get_cache_file_path()
+    relative_paths = sorted([os.path.relpath(f[0]) for f in files_to_include])
+    try:
+        with open(cache_file, 'w', encoding='utf-8') as f:
+            json.dump(relative_paths, f, indent=2)
+    except IOError as e:
+        print(f"\nWarning: Could not save selection to cache: {e}")
+
+def load_selection_from_cache() -> List[str]:
+    """Loads the list of selected files from the cache file."""
+    cache_file = get_cache_file_path()
+    if not cache_file.exists():
+        return []
+    try:
+        with open(cache_file, 'r', encoding='utf-8') as f:
+            paths = json.load(f)
+            # Filter out paths that no longer exist
+            return [p for p in paths if os.path.exists(p)]
+    except (IOError, json.JSONDecodeError) as e:
+        print(f"\nWarning: Could not load previous selection from cache: {e}")
+        return []

kopipasta-0.32.0/kopipasta/file.py

@@ -0,0 +1,129 @@
+import fnmatch
+import os
+from typing import List, Optional, Tuple
+from pathlib import Path
+
+FileTuple = Tuple[str, bool, Optional[List[str]], str]
+
+# --- Cache for .gitignore patterns ---
+# Key: Directory path
+# Value: List of patterns
+_gitignore_cache: dict[str, list[str]] = {}
+
+def _read_gitignore_patterns(gitignore_path: str) -> list[str]:
+    """Reads patterns from a single .gitignore file and caches them."""
+    if gitignore_path in _gitignore_cache:
+        return _gitignore_cache[gitignore_path]
+    if not os.path.isfile(gitignore_path):
+        _gitignore_cache[gitignore_path] = []
+        return []
+    patterns = []
+    try:
+        with open(gitignore_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                stripped_line = line.strip()
+                if stripped_line and not stripped_line.startswith('#'):
+                    patterns.append(stripped_line)
+    except IOError:
+        pass
+    _gitignore_cache[gitignore_path] = patterns
+    return patterns
+
+def is_ignored(path: str, default_ignore_patterns: list[str], project_root: Optional[str] = None) -> bool:
+    """
+    Checks if a path should be ignored based on default patterns and .gitignore files.
+    Searches for .gitignore from the path's location up to the project_root.
+    """
+    path_abs = os.path.abspath(path)
+    if project_root is None:
+        project_root = os.getcwd()
+    project_root_abs = os.path.abspath(project_root)
+
+    # --- Step 1: Gather all patterns from all relevant .gitignore files ---
+    all_patterns = set(default_ignore_patterns)
+    
+    # Determine the directory to start searching for .gitignore files
+    search_start_dir = path_abs if os.path.isdir(path_abs) else os.path.dirname(path_abs)
+
+    current_dir = search_start_dir
+    while True:
+        gitignore_path = os.path.join(current_dir, ".gitignore")
+        patterns_from_file = _read_gitignore_patterns(gitignore_path)
+
+        if patterns_from_file:
+            gitignore_dir_rel = os.path.relpath(current_dir, project_root_abs)
+            if gitignore_dir_rel == '.': gitignore_dir_rel = ''
+
+            for p in patterns_from_file:
+                # Patterns with a '/' are relative to the .gitignore file's location.
+                # We construct a new pattern relative to the project root.
+                if '/' in p:
+                    all_patterns.add(os.path.join(gitignore_dir_rel, p.lstrip('/')))
+                else:
+                    # Patterns without a '/' (e.g., `*.log`) can match anywhere.
+                    all_patterns.add(p)
+
+        if not current_dir.startswith(project_root_abs) or current_dir == project_root_abs:
+            break
+        parent = os.path.dirname(current_dir)
+        if parent == current_dir: break
+        current_dir = parent
+
+    # --- Step 2: Check the path and its parents against the patterns ---
+    try:
+        path_rel_to_root = os.path.relpath(path_abs, project_root_abs)
+    except ValueError:
+        return False # Path is outside the project root
+
+    path_parts = Path(path_rel_to_root).parts
+
+    for pattern in all_patterns:
+        # Check against basename for simple wildcards (e.g., `*.log`, `__pycache__`)
+        # This is a primary matching mechanism.
+        if fnmatch.fnmatch(os.path.basename(path_abs), pattern):
+            return True
+            
+        # Check the full path and its parent directories against the pattern.
+        # This handles directory ignores (`node_modules/`) and specific path ignores (`src/*.tmp`).
+        for i in range(len(path_parts)):
+            current_check_path = os.path.join(*path_parts[:i+1])
+            
+            # Handle directory patterns like `node_modules/`
+            if pattern.endswith('/'):
+                if fnmatch.fnmatch(current_check_path, pattern.rstrip('/')):
+                    return True
+            # Handle full path patterns
+            else:
+                if fnmatch.fnmatch(current_check_path, pattern):
+                    return True
+    
+    return False
+
+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 is_binary(file_path):
+    try:
+        with open(file_path, 'rb') as file:
+            chunk = file.read(1024)
+            if b'\0' in chunk:
+                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):
+    return os.path.getsize(file_path) > threshold

{kopipasta-0.30.0 → kopipasta-0.32.0}/kopipasta/main.py

@@ -18,6 +18,7 @@ from kopipasta.file import FileTuple, get_human_readable_size, is_binary, is_ign
 import kopipasta.import_parser as import_parser
 from kopipasta.tree_selector import TreeSelector
 from kopipasta.prompt import generate_prompt_template, get_file_snippet, get_language_for_file
+from kopipasta.cache import save_selection_to_cache
 
 def _propose_and_add_dependencies(
     file_just_added: str,
@@ -136,7 +137,7 @@ def read_gitignore():
         '.terraform', 'output', 'poetry.lock', 'package-lock.json', '.env',
         '*.log', '*.bak', '*.swp', '*.swo', '*.tmp', 'tmp', 'temp', 'logs',
         'build', 'target', '.DS_Store', 'Thumbs.db', '*.class', '*.jar',
-        '*.war', '*.ear', '*.sqlite', '*.db', '.github', '.gitignore',
+        '*.war', '*.ear', '*.sqlite', '*.db',
         '*.jpg', '*.jpeg', '*.png', '*.gif', '*.bmp', '*.tiff',
         '*.ico', '*.svg', '*.webp', '*.mp3', '*.mp4', '*.avi',
         '*.mov', '*.wmv', '*.flv', '*.pdf', '*.doc', '*.docx',
@@ -489,7 +490,7 @@ def grep_files_in_directory(pattern: str, directory: str, ignore_patterns: List[
         grep_results = []
         
         for file in files:
-            if is_ignored(file, ignore_patterns) or is_binary(file):
+            if is_ignored(file, ignore_patterns, directory) or is_binary(file):
                 continue
                 
             # Get match count and preview lines
@@ -993,10 +994,14 @@ def open_editor_for_input(template: str, cursor_position: int) -> str:
 
 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('inputs', nargs='*', help='Files, directories, or URLs to include. Defaults to current directory.')
     parser.add_argument('-t', '--task', help='Task description for the AI prompt')
     args = parser.parse_args()
 
+    # Default to the current directory if no inputs are provided
+    if not args.inputs:
+        args.inputs.append('.')
+
     ignore_patterns = read_gitignore()
     env_vars = read_env_file()
     project_root_abs = os.path.abspath(os.getcwd())
@@ -1007,6 +1012,7 @@ def main():
     
     # Separate URLs from file/directory paths
     paths_for_tree = []
+    files_to_preselect = []
     
     for input_path in args.inputs:
         if input_path.startswith(('http://', 'https://')):
@@ -1045,20 +1051,22 @@ def main():
                 print(f"Added {'snippet of ' if is_snippet else ''}web content from: {input_path}")
                 print_char_count(current_char_count)
         else:
-            # Add to paths for tree selector
-            if os.path.exists(input_path):
+            abs_path = os.path.abspath(input_path)
+            if os.path.exists(abs_path):
                 paths_for_tree.append(input_path)
+                if os.path.isfile(abs_path):
+                    files_to_preselect.append(abs_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")
+        print("Use arrow keys to navigate, Space to select, 'q' to finish. See all keys below.\n")
         
         tree_selector = TreeSelector(ignore_patterns, project_root_abs)
         try:
-            selected_files, file_char_count = tree_selector.run(paths_for_tree)
+            selected_files, file_char_count = tree_selector.run(paths_for_tree, files_to_preselect)
             files_to_include.extend(selected_files)
             current_char_count += file_char_count
         except KeyboardInterrupt:
@@ -1069,6 +1077,10 @@ def main():
         print("No files or web content were selected. Exiting.")
         return
 
+    # Save the final selection for the next run
+    if files_to_include:
+        save_selection_to_cache(files_to_include)
+
     print("\nFile and web content selection complete.")
     print_char_count(current_char_count)
 
@@ -1098,8 +1110,25 @@ def main():
 
     try:
         pyperclip.copy(final_prompt)
+        print("\n--- Included Files & Content ---\n")
+        for file_path, is_snippet, chunks, _ in sorted(files_to_include, key=lambda x: x[0]):
+            details = []
+            if is_snippet:
+                details.append("snippet")
+            if chunks is not None:
+                details.append(f"{len(chunks)} patches")
+            
+            detail_str = f" ({', '.join(details)})" if details else ""
+            print(f"- {os.path.relpath(file_path)}{detail_str}")
+
+        for url, (file_tuple, _) in sorted(web_contents.items()):
+            is_snippet = file_tuple[1]
+            detail_str = " (snippet)" if is_snippet else ""
+            print(f"- {url}{detail_str}")
+        
         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)")

{kopipasta-0.30.0 → kopipasta-0.32.0}/kopipasta/tree_selector.py

@@ -9,31 +9,28 @@ import click
 
 from kopipasta.file import FileTuple, is_binary, is_ignored, get_human_readable_size
 from kopipasta.prompt import get_file_snippet, get_language_for_file
+from kopipasta.cache import load_selection_from_cache
 
 
 class FileNode:
     """Represents a file or directory in the tree"""
-    def __init__(self, path: str, is_dir: bool, parent: Optional['FileNode'] = None):
-        self.path = os.path.abspath(path)  # Always store absolute paths
+    def __init__(self, path: str, is_dir: bool, parent: Optional['FileNode'] = None, is_scan_root: bool = False):
+        self.path = os.path.abspath(path)
         self.is_dir = is_dir
         self.parent = parent
         self.children: List['FileNode'] = []
         self.expanded = False
-        self.selected = False
-        self.selected_as_snippet = False
+        # This flag marks the invisible root of the file tree, which is not meant to be displayed.
+        self.is_scan_root = is_scan_root
         self.size = 0 if is_dir else os.path.getsize(self.path)
-        self.is_root = path == "."  # Mark if this is the root node
         
     @property
     def name(self):
-        if self.is_root:
-            return "."  # Show root as "." instead of directory name
         return os.path.basename(self.path) or self.path
         
     @property
     def relative_path(self):
-        if self.is_root:
-            return "."
+        # os.path.relpath is relative to the current working directory by default
         return os.path.relpath(self.path)
 
 
@@ -53,33 +50,33 @@ class TreeSelector:
         self.viewport_offset = 0  # First visible item index
         
     def build_tree(self, paths: List[str]) -> FileNode:
-        """Build tree structure from given paths"""
-        # Use current directory as root
-        root = FileNode(".", True)
-        root.expanded = True  # Always expand root
-        
-        # Process each input path
+        """Build tree structure from given paths."""
+        # If one directory is given, make its contents the top level of the tree.
+        if len(paths) == 1 and os.path.isdir(paths[0]):
+            root_path = os.path.abspath(paths[0])
+            root = FileNode(root_path, True, is_scan_root=True)
+            root.expanded = True
+            self._scan_directory(root_path, root)
+            return root
+
+        # Otherwise, create a virtual root to hold multiple items (e.g., `kopipasta file.py dir/`).
+        # This virtual root itself won't be displayed.
+        virtual_root_path = os.path.join(self.project_root_abs, "__kopipasta_virtual_root__")
+        root = FileNode(virtual_root_path, True, is_scan_root=True)
+        root.expanded = True
+
         for path in paths:
             abs_path = os.path.abspath(path)
-            
+            node = None
             if os.path.isfile(abs_path):
-                # Single file - add to root
-                if not is_ignored(abs_path, self.ignore_patterns) and not is_binary(abs_path):
+                if not is_ignored(abs_path, self.ignore_patterns, self.project_root_abs) and not is_binary(abs_path):
                     node = FileNode(abs_path, False, root)
-                    root.children.append(node)
             elif os.path.isdir(abs_path):
-                # If the directory is the current directory, scan its contents directly
-                if abs_path == os.path.abspath("."):
-                    self._scan_directory(abs_path, root)
-                else:
-                    # Otherwise add the directory as a child
-                    dir_node = FileNode(abs_path, True, root)
-                    root.children.append(dir_node)
-                    # Auto-expand if it's the only child
-                    if len(paths) == 1:
-                        dir_node.expanded = True
-                        self._scan_directory(abs_path, dir_node)
-                
+                node = FileNode(abs_path, True, root)
+
+            if node:
+                root.children.append(node)
+
         return root
     
     def _scan_directory(self, dir_path: str, parent_node: FileNode):
@@ -101,7 +98,7 @@ class TreeSelector:
         
         for item in items:
             item_path = os.path.join(abs_dir_path, item)
-            if is_ignored(item_path, self.ignore_patterns):
+            if is_ignored(item_path, self.ignore_patterns, self.project_root_abs):
                 continue
                 
             if os.path.isdir(item_path):
@@ -130,23 +127,18 @@ class TreeSelector:
                 parent_node.children.append(file_node)
     
     def _flatten_tree(self, node: FileNode, level: int = 0) -> List[Tuple[FileNode, int]]:
-        """Flatten tree into a list of (node, level) tuples for display"""
+        """Flatten tree into a list of (node, level) tuples for display."""
         result = []
         
-        # Special handling for root - show its children at top level
-        if node.is_root:
-            # Don't include the root node itself in the display
+        # If it's the special root node, don't display it. Display its children at the top level.
+        if node.is_scan_root:
             for child in node.children:
-                result.extend(self._flatten_tree(child, 0))  # Start children at level 0
+                result.extend(self._flatten_tree(child, 0))
         else:
-            # Include this node
             result.append((node, level))
-            
             if node.is_dir and node.expanded:
-                # Load children on demand if not loaded
                 if not node.children:
                     self._scan_directory(node.path, node)
-                    
                 for child in node.children:
                     result.extend(self._flatten_tree(child, level + 1))
                 
@@ -155,10 +147,10 @@ class TreeSelector:
     def _build_display_tree(self) -> Tree:
         """Build Rich tree for display with viewport"""
         # Get terminal size
-        term_width, term_height = shutil.get_terminal_size()
+        _, term_height = shutil.get_terminal_size()
         
         # Reserve space for header, help panel, and status
-        available_height = term_height - 15  # Adjust based on your UI
+        available_height = term_height - 8
         available_height = max(5, available_height)  # Minimum height
         
         # Flatten tree to get all visible nodes
@@ -253,15 +245,16 @@ class TreeSelector:
     def _show_help(self) -> Panel:
         """Create help panel"""
         help_text = """[bold]Navigation:[/bold]
-↑/k: Up  ↓/j: Down  →/l/Enter: Expand  ←/h: Collapse  PgUp/PgDn: Page  G/End: Bottom
+↑/k: Up  ↓/j: Down  →/l/Enter: Expand  ←/h: Collapse
 
 [bold]Selection:[/bold]  
 Space: Toggle file/dir     a: Add all in dir     s: Snippet mode
 
 [bold]Actions:[/bold]
-g: Grep in directory     d: Show dependencies     q: Quit selection"""
+r: Reuse last selection  g: Grep in directory   d: Show dependencies
+q: Quit and finalize"""
         
-        return Panel(help_text, title="Keys", border_style="dim", expand=False)
+        return Panel(help_text, title="Keyboard Controls", border_style="dim", expand=False)
     
     def _get_status_bar(self) -> str:
         """Create status bar with selection info"""
@@ -336,10 +329,7 @@ g: Grep in directory     d: Show dependencies     q: Quit selection"""
                 # Unselect
                 is_snippet, _ = self.selected_files[abs_path]
                 del self.selected_files[abs_path]
-                if is_snippet:
-                    self.char_count -= len(get_file_snippet(node.path))
-                else:
-                    self.char_count -= node.size
+                self.char_count -= len(get_file_snippet(node.path)) if is_snippet else node.size
             else:
                 # Select
                 if snippet_mode or (node.size > 102400 and not self._confirm_large_file(node)):
@@ -352,7 +342,7 @@ g: Grep in directory     d: Show dependencies     q: Quit selection"""
                     self.char_count += node.size
     
     def _toggle_directory(self, node: FileNode):
-        """Toggle all files in a directory"""
+        """Toggle all files in a directory, now fully recursive."""
         if not node.is_dir:
             return
             
@@ -365,6 +355,9 @@ g: Grep in directory     d: Show dependencies     q: Quit selection"""
         
         def collect_files(n: FileNode):
             if n.is_dir:
+                # CRITICAL FIX: Ensure sub-directory children are loaded before recursing
+                if not n.children:
+                    self._scan_directory(n.path, n)
                 for child in n.children:
                     collect_files(child)
             else:
@@ -376,16 +369,92 @@ g: Grep in directory     d: Show dependencies     q: Quit selection"""
         any_unselected = any(os.path.abspath(f.path) not in self.selected_files for f in all_files)
         
         if any_unselected:
-            # Select all unselected
+            # Select all unselected files
             for file_node in all_files:
-                if file_node.path not in self.selected_files:
-                    self._toggle_selection(file_node)
+                abs_path = os.path.abspath(file_node.path)
+                if abs_path not in self.selected_files:
+                    self.selected_files[abs_path] = (False, None)
+                    self.char_count += file_node.size
         else:
-            # Unselect all
+            # Unselect all files
             for file_node in all_files:
-                if file_node.path in self.selected_files:
-                    self._toggle_selection(file_node)
-    
+                abs_path = os.path.abspath(file_node.path)
+                if abs_path in self.selected_files:
+                    is_snippet, _ = self.selected_files[abs_path]
+                    del self.selected_files[abs_path]
+                    if is_snippet:
+                        self.char_count -= len(get_file_snippet(file_node.path))
+                    else:
+                        self.char_count -= file_node.size
+
+    def _propose_and_apply_last_selection(self):
+        """Loads paths from cache, shows a confirmation dialog, and applies the selection if confirmed."""
+        cached_paths = load_selection_from_cache()
+
+        if not cached_paths:
+            self.console.print(Panel("[yellow]No cached selection found to reuse.[/yellow]", title="Info", border_style="dim"))
+            click.pause("Press any key to continue...")
+            return
+
+        # Categorize cached paths for the preview
+        files_to_add = []
+        files_already_selected = []
+        files_not_found = []
+
+        for rel_path in cached_paths:
+            abs_path = os.path.abspath(rel_path)
+            if not os.path.isfile(abs_path):
+                files_not_found.append(rel_path)
+                continue
+
+            if abs_path in self.selected_files:
+                files_already_selected.append(rel_path)
+            else:
+                files_to_add.append(rel_path)
+        
+        # Build the rich text for the confirmation panel
+        preview_text = Text()
+        if files_to_add:
+            preview_text.append("The following files will be ADDED:\n", style="bold")
+            for path in sorted(files_to_add):
+                preview_text.append("  ")
+                preview_text.append("+", style="cyan")
+                preview_text.append(f" {path}\n")
+        
+        if files_already_selected:
+            preview_text.append("\nAlready selected (no change):\n", style="bold dim")
+            for path in sorted(files_already_selected):
+                preview_text.append(f"  ✓ {path}\n")
+
+        if files_not_found:
+            preview_text.append("\nNot found on disk (will be skipped):\n", style="bold dim")
+            for path in sorted(files_not_found):
+                preview_text.append("  ")
+                preview_text.append("-", style="red")
+                preview_text.append(f" {path}\n")
+
+        # Display the confirmation panel and prompt
+        self.console.clear()
+        self.console.print(Panel(preview_text, title="[bold cyan]Reuse Last Selection?", border_style="cyan", padding=(1, 2)))
+        
+        if not files_to_add:
+            self.console.print("\n[yellow]No new files to add from the last selection.[/yellow]")
+            click.pause("Press any key to continue...")
+            return
+
+        # Use click.confirm for a simple and effective y/n prompt
+        if not click.confirm(f"\nAdd {len(files_to_add)} file(s) to your current selection?", default=True):
+            return
+
+        # If confirmed, apply the changes
+        for rel_path in files_to_add:
+            abs_path = os.path.abspath(rel_path)
+            if os.path.isfile(abs_path) and abs_path not in self.selected_files:
+                file_size = os.path.getsize(abs_path)
+                self.selected_files[abs_path] = (False, None)
+                self.char_count += file_size
+                self._ensure_path_visible(abs_path)
+
     def _ensure_path_visible(self, file_path: str):
         """Ensure a file path is visible in the tree by expanding parent directories"""
         abs_file_path = os.path.abspath(file_path)
@@ -458,10 +527,32 @@ g: Grep in directory     d: Show dependencies     q: Quit selection"""
             
         self.char_count += deps_char_count
     
-    def run(self, initial_paths: List[str]) -> Tuple[List[FileTuple], int]:
+    def _preselect_files(self, files_to_preselect: List[str]):
+        """Pre-selects a list of files passed from the command line."""
+        if not files_to_preselect:
+            return
+
+        added_count = 0
+        for file_path in files_to_preselect:
+            abs_path = os.path.abspath(file_path)
+            if abs_path in self.selected_files:
+                continue
+
+            # This check is simpler than a full tree walk and sufficient here
+            if os.path.isfile(abs_path) and not is_binary(abs_path):
+                file_size = os.path.getsize(abs_path)
+                self.selected_files[abs_path] = (False, None) # (is_snippet=False, chunks=None)
+                self.char_count += file_size
+                added_count += 1
+                self._ensure_path_visible(abs_path)
+
+    def run(self, initial_paths: List[str], files_to_preselect: Optional[List[str]] = None) -> Tuple[List[FileTuple], int]:
         """Run the interactive tree selector"""
         self.root = self.build_tree(initial_paths)
         
+        if files_to_preselect:
+            self._preselect_files(files_to_preselect)
+
         # Don't use Live mode, instead manually control the display
         while not self.quit_selection:
             # Clear and redraw
@@ -529,10 +620,11 @@ g: Grep in directory     d: Show dependencies     q: Quit selection"""
                         self._toggle_directory(current_node)
                         
                 # Handle actions
+                elif key == 'r':  # Reuse last selection
+                    self._propose_and_apply_last_selection()
                 elif key == 'g':  # Grep
                     self.console.print()  # Add some space
                     self._handle_grep(current_node)
-                    click.pause("Press any key to continue...")
                 elif key == 'd':  # Dependencies
                     self.console.print()  # Add some space
                     self._show_dependencies(current_node)

{kopipasta-0.30.0 → kopipasta-0.32.0/kopipasta.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.30.0
+Version: 0.32.0
 Summary: A CLI tool to generate prompts with project structure and file contents
 Home-page: https://github.com/mkorpela/kopipasta
 Author: Mikko Korpela

{kopipasta-0.30.0 → kopipasta-0.32.0}/kopipasta.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 requirements.txt
 setup.py
 kopipasta/__init__.py
+kopipasta/cache.py
 kopipasta/file.py
 kopipasta/import_parser.py
 kopipasta/main.py
@@ -14,4 +15,6 @@ kopipasta.egg-info/SOURCES.txt
 kopipasta.egg-info/dependency_links.txt
 kopipasta.egg-info/entry_points.txt
 kopipasta.egg-info/requires.txt
-kopipasta.egg-info/top_level.txt
+kopipasta.egg-info/top_level.txt
+tests/test_file.py
+tests/test_tree_selector.py

{kopipasta-0.30.0 → kopipasta-0.32.0}/setup.py

@@ -10,7 +10,7 @@ with open("requirements.txt", "r", encoding="utf-8") as f:
 
 setup(
     name="kopipasta",
-    version="0.30.0",
+    version="0.32.0",
     author="Mikko Korpela",
     author_email="mikko.korpela@gmail.com",
     description="A CLI tool to generate prompts with project structure and file contents",

kopipasta-0.32.0/tests/test_file.py

@@ -0,0 +1,65 @@
+import pytest
+from pathlib import Path
+from kopipasta.file import is_ignored
+
+@pytest.fixture
+def project_root(tmp_path: Path) -> Path:
+    """Creates a mock project structure for testing ignore patterns."""
+    project_dir = tmp_path / "project"
+    project_dir.mkdir()
+
+    # Root .gitignore
+    (project_dir / ".gitignore").write_text("*.log\nnode_modules/\n")
+    (project_dir / "file.log").touch()
+    (project_dir / "main.py").touch()
+    (project_dir / "node_modules").mkdir()
+    (project_dir / "node_modules" / "some_lib").touch()
+
+    # Subdirectory with its own .gitignore
+    sub_dir = project_dir / "src"
+    sub_dir.mkdir()
+    (sub_dir / ".gitignore").write_text("*.tmp\n__pycache__/\n")
+    (sub_dir / "component.js").touch()
+    (sub_dir / "component.tmp").touch()
+    (sub_dir / "__pycache__").mkdir()
+    (sub_dir / "__pycache__" / "cache_file").touch()
+
+    # Nested subdirectory to test cascading
+    nested_dir = sub_dir / "api"
+    nested_dir.mkdir()
+    (nested_dir / "endpoint.py").touch()
+    (nested_dir / "endpoint.log").touch() # Should be ignored by root .gitignore
+    (nested_dir / "endpoint.tmp").touch() # Should be ignored by subdir .gitignore
+
+    return project_dir
+
+def test_is_ignored_with_nested_gitignores(project_root: Path):
+    """
+    Tests that is_ignored correctly respects .gitignore files from the current
+    directory up to the project root.
+    """
+    # Test cases: path, expected_result
+    test_cases = [
+        # Root level ignores
+        ("file.log", True),
+        ("main.py", False),
+        ("node_modules/some_lib", True),
+        ("node_modules", True),
+
+        # Subdirectory level ignores
+        ("src/component.js", False),
+        ("src/component.tmp", True),
+        ("src/__pycache__/cache_file", True),
+        ("src/__pycache__", True),
+
+        # Nested subdirectory, checking cascading ignores
+        ("src/api/endpoint.py", False),
+        ("src/api/endpoint.log", True),  # Ignored by root .gitignore
+        ("src/api/endpoint.tmp", True),  # Ignored by src/.gitignore
+    ]
+
+    # The ignore patterns would be dynamically loaded by the new logic,
+    # so we pass an empty list and let the function handle discovery.
+    for rel_path, expected in test_cases:
+        full_path = project_root / rel_path
+        assert is_ignored(str(full_path), [], str(project_root)) == expected, f"Failed on path: {rel_path}"

kopipasta-0.32.0/tests/test_tree_selector.py

@@ -0,0 +1,47 @@
+import os
+import pytest
+from pathlib import Path
+from kopipasta.tree_selector import TreeSelector
+
+@pytest.fixture
+def mock_project(tmp_path: Path) -> Path:
+    """Creates a mock project structure for testing TreeSelector."""
+    proj = tmp_path / "selector_project"
+    proj.mkdir()
+    (proj / "main.py").write_text("print('hello')")
+    (proj / "README.md").write_text("# Test Project")
+    sub = proj / "src"
+    sub.mkdir()
+    (sub / "component.js").write_text("console.log('test');")
+    # Change CWD into the mock project for the duration of the test
+    original_cwd = os.getcwd()
+    os.chdir(proj)
+    yield proj
+    os.chdir(original_cwd)
+
+def test_preselects_files_from_command_line(mock_project: Path):
+    """
+    Tests that TreeSelector correctly pre-selects files passed to it.
+    """
+    main_py_abs = os.path.abspath("main.py")
+    component_js_abs = os.path.abspath("src/component.js")
+    
+    files_to_preselect = [main_py_abs, component_js_abs]
+    
+    # Instantiate the selector and manually run the pre-selection logic
+    selector = TreeSelector(ignore_patterns=[], project_root_abs=str(mock_project))
+    
+    # We pass all potential paths to build_tree
+    selector.root = selector.build_tree(["."])
+    selector._preselect_files(files_to_preselect)
+
+    # Assertions
+    assert len(selector.selected_files) == 2
+    assert main_py_abs in selector.selected_files
+    assert component_js_abs in selector.selected_files
+    
+    assert not selector.selected_files[main_py_abs][0]
+    assert not selector.selected_files[component_js_abs][0]
+    
+    expected_char_count = os.path.getsize(main_py_abs) + os.path.getsize(component_js_abs)
+    assert selector.char_count == expected_char_count

kopipasta-0.30.0/kopipasta/file.py

@@ -1,47 +0,0 @@
-import fnmatch
-import os
-from typing import List, Optional, Tuple
-
-
-FileTuple = Tuple[str, bool, Optional[List[str]], str]
-
-
-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 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