kopipasta 0.31.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

kopipasta/file.py

@@ -1,10 +1,103 @@
 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:
@@ -14,20 +107,11 @@ def read_file_contents(file_path):
         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
+            if b'\0' in chunk:
                 return True
             if file_path.lower().endswith(('.json', '.csv')):
                 return False
@@ -35,13 +119,11 @@ def is_binary(file_path):
     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
+def is_large_file(file_path, threshold=102400):
     return os.path.getsize(file_path) > threshold

kopipasta/main.py

@@ -137,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',
@@ -490,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
@@ -1012,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://')):
@@ -1050,9 +1051,11 @@ 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.")
     
@@ -1063,7 +1066,7 @@ def main():
         
         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:
@@ -1107,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/tree_selector.py

@@ -14,27 +14,23 @@ 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)
 
 
@@ -54,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):
@@ -102,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):
@@ -131,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))
                 
@@ -156,10 +147,11 @@ 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
+        reserved_space = 17
+        available_height = term_height - reserved_space
         available_height = max(5, available_height)  # Minimum height
         
         # Flatten tree to get all visible nodes
@@ -338,10 +330,7 @@ q: Quit and finalize"""
                 # 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)):
@@ -539,10 +528,32 @@ q: Quit and finalize"""
             
         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

{kopipasta-0.31.0.dist-info → kopipasta-0.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.31.0
+Version: 0.33.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.33.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kopipasta/cache.py,sha256=rH52yX3g7p22_1NXmrBDcBEntm3ivMjtV8n8zxTLY1k,1454
+kopipasta/file.py,sha256=tPCLNvSXHzIvAXLB6fgJswLpCFce7T1QnbNdSWHbIso,4829
+kopipasta/import_parser.py,sha256=yLzkMlQm2avKjfqcpMY0PxbA_2ihV9gSYJplreWIPEQ,12424
+kopipasta/main.py,sha256=YzzEnDph1v3NojHYIjvD3Z4blnIEX5zqj9W6gNLlA7E,50058
+kopipasta/prompt.py,sha256=fOCuJVTLUfR0fjKf5qIlnl_3pNsKNKsvt3C8f4tsmxk,6889
+kopipasta/tree_selector.py,sha256=VIBmPq5cTHU-xUJuXV3K58nn1zS-1X079WAFzfS2vCA,28247
+kopipasta-0.33.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
+kopipasta-0.33.0.dist-info/METADATA,sha256=Fs44BJq3C5tqpIdzccr6APhyx97UU0JHjlcTb1uqzuI,4894
+kopipasta-0.33.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+kopipasta-0.33.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
+kopipasta-0.33.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
+kopipasta-0.33.0.dist-info/RECORD,,

kopipasta-0.31.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kopipasta/cache.py,sha256=rH52yX3g7p22_1NXmrBDcBEntm3ivMjtV8n8zxTLY1k,1454
-kopipasta/file.py,sha256=2HEoNczbKH3TtLO0zYUcZfUoHqb0-o83xFUOgY9rG-Y,1244
-kopipasta/import_parser.py,sha256=yLzkMlQm2avKjfqcpMY0PxbA_2ihV9gSYJplreWIPEQ,12424
-kopipasta/main.py,sha256=3Sle6pFEko4HSCXClmEb1L4QsN41VEOd0ZuzxeUDFUk,49210
-kopipasta/prompt.py,sha256=fOCuJVTLUfR0fjKf5qIlnl_3pNsKNKsvt3C8f4tsmxk,6889
-kopipasta/tree_selector.py,sha256=Iov8KLFopb7OLvX-xhn0FmFy0Ee5rFpPYzV6JLxCR84,27614
-kopipasta-0.31.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
-kopipasta-0.31.0.dist-info/METADATA,sha256=RO8xJpSYGdqzsr-A7a22wTJEu2EwF_xtzJaziMD9XUw,4894
-kopipasta-0.31.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-kopipasta-0.31.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
-kopipasta-0.31.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
-kopipasta-0.31.0.dist-info/RECORD,,