kopipasta 0.31.0__tar.gz → 0.32.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.31.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/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.31.0 → kopipasta-0.32.0}/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-0.31.0 → kopipasta-0.32.0}/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,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
@@ -338,10 +329,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 +527,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 → kopipasta-0.32.0/kopipasta.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.31.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.31.0 → kopipasta-0.32.0}/kopipasta.egg-info/SOURCES.txt

@@ -15,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.31.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.31.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.31.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