kopipasta 0.34.0__tar.gz → 0.35.0__tar.gz

{kopipasta-0.34.0/kopipasta.egg-info → kopipasta-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.34.0
+Version: 0.35.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.34.0 → kopipasta-0.35.0}/kopipasta/tree_selector.py

@@ -20,9 +20,12 @@ class FileNode:
         self.parent = parent
         self.children: List['FileNode'] = []
         self.expanded = 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
+        # Base size (for files) or initial placeholder (for dirs)
         self.size = 0 if is_dir else os.path.getsize(self.path)
+        # New attributes for caching the results of a deep scan
+        self.total_size: int = self.size
+        self.is_scanned: bool = not self.is_dir
         
     @property
     def name(self):
@@ -48,7 +51,41 @@ class TreeSelector:
         self.char_count = 0
         self.quit_selection = False
         self.viewport_offset = 0  # First visible item index
+        self._metrics_cache: Dict[str, Tuple[int, int]] = {}
+
+    def _calculate_directory_metrics(self, node: FileNode) -> Tuple[int, int]:
+        """Recursively calculate total and selected size for a directory."""
+        if not node.is_dir:
+            return 0, 0
         
+        # Use instance cache for this render cycle
+        if node.path in self._metrics_cache:
+            return self._metrics_cache[node.path]
+
+        total_size = 0
+        selected_size = 0
+
+        # Ensure directory is scanned
+        if not node.children:
+            self._deep_scan_directory_and_calc_size(node.path, node)
+
+        for child in node.children:
+            if child.is_dir:
+                child_total, child_selected = self._calculate_directory_metrics(child)
+                total_size += child_total
+                selected_size += child_selected
+            else: # It's a file
+                total_size += child.size
+                if child.path in self.selected_files:
+                    is_snippet, _ = self.selected_files[child.path]
+                    if is_snippet:
+                        selected_size += len(get_file_snippet(child.path))
+                    else:
+                        selected_size += child.size
+
+        self._metrics_cache[node.path] = (total_size, selected_size)
+        return total_size, selected_size
+
     def build_tree(self, paths: List[str]) -> FileNode:
         """Build tree structure from given paths."""
         # If one directory is given, make its contents the top level of the tree.
@@ -56,7 +93,7 @@ class TreeSelector:
             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)
+            self._deep_scan_directory_and_calc_size(root_path, root)
             return root
 
         # Otherwise, create a virtual root to hold multiple items (e.g., `kopipasta file.py dir/`).
@@ -79,7 +116,7 @@ class TreeSelector:
 
         return root
     
-    def _scan_directory(self, dir_path: str, parent_node: FileNode):
+    def _deep_scan_directory_and_calc_size(self, dir_path: str, parent_node: FileNode):
         """Recursively scan directory and build tree"""
         abs_dir_path = os.path.abspath(dir_path)
         
@@ -138,7 +175,7 @@ class TreeSelector:
             result.append((node, level))
             if node.is_dir and node.expanded:
                 if not node.children:
-                    self._scan_directory(node.path, node)
+                    self._deep_scan_directory_and_calc_size(node.path, node)
                 for child in node.children:
                     result.extend(self._flatten_tree(child, level + 1))
                 
@@ -146,6 +183,8 @@ class TreeSelector:
     
     def _build_display_tree(self) -> Tree:
         """Build Rich tree for display with viewport"""
+        self._metrics_cache = {} # Clear cache for each new render
+        
         # Get terminal size
         _, term_height = shutil.get_terminal_size()
         
@@ -177,10 +216,9 @@ class TreeSelector:
         if self.viewport_offset > 0:
             tree_title += f" ↑ ({self.viewport_offset} more)"
         
-        tree = Tree(tree_title, guide_style="dim")
+        tree = Tree(tree_title)
         
         # Build tree structure - only for visible portion
-        node_map = {}
         viewport_end = min(len(flat_tree), self.viewport_offset + available_height)
         
         # Track what level each visible item is at for proper tree structure
@@ -193,30 +231,35 @@ class TreeSelector:
             is_current = i == self.current_index
             style = "bold cyan" if is_current else ""
             
+            label = Text()
+
             if node.is_dir:
                 icon = "📂" if node.expanded else "📁"
-                size_str = f" ({len(node.children)} items)" if node.children else ""
-            else:
+                total_size, selected_size = self._calculate_directory_metrics(node)
+                if total_size > 0:
+                    size_str = f" ({get_human_readable_size(selected_size)} / {get_human_readable_size(total_size)})"
+                else:
+                    size_str = "" # Don't show size for empty dirs
+                
+                # Omit the selection circle for directories
+                label.append(f"{icon} {node.name}{size_str}", style=style)
+
+            else: # It's a file
                 icon = "📄"
                 size_str = f" ({get_human_readable_size(node.size)})"
                 
-            # Selection indicator
-            abs_path = os.path.abspath(node.path)
-            if abs_path in self.selected_files:
-                is_snippet = self.selected_files[abs_path][0]
-                if is_snippet:
-                    selection = "◐"  # Half-selected (snippet)
+                # File selection indicator
+                abs_path = os.path.abspath(node.path)
+                if abs_path in self.selected_files:
+                    is_snippet, _ = self.selected_files[abs_path]
+                    selection = "◐" if is_snippet else "●"
+                    style = "green " + style
                 else:
-                    selection = "●"  # Fully selected
-                style = "green " + style
-            else:
-                selection = "○"
+                    selection = "○"
                 
-            # Build label
-            label = Text()
-            label.append(f"{selection} ", style="dim")
-            label.append(f"{icon} {node.name}{size_str}", style=style)
-            
+                label.append(f"{selection} ", style="dim")
+                label.append(f"{icon} {node.name}{size_str}", style=style)
+
             # Add to tree at correct level
             if level == 0:
                 tree_node = tree.add(label)
@@ -230,10 +273,17 @@ class TreeSelector:
                     level_stacks[level] = tree_node
                 else:
                     # Fallback - add to root with indentation indicator
-                    indent_label = Text()
-                    indent_label.append("  " * level + f"{selection} ", style="dim")
-                    indent_label.append(f"{icon} {node.name}{size_str}", style=style)
-                    tree_node = tree.add(indent_label)
+                    indent_text = "  " * level
+                    if not node.is_dir:
+                         # Re-add file selection marker for indented fallback
+                        selection_char = "○"
+                        if node.path in self.selected_files:
+                            selection_char = "◐" if self.selected_files[node.path][0] else "●"
+                        indent_text += f"{selection_char} "
+                    
+                    # Create a new label with proper indentation for this edge case
+                    fallback_label_text = f"{indent_text}{label.plain}"
+                    tree_node = tree.add(Text(fallback_label_text, style=style))
                     level_stacks[level] = tree_node
         
         # Add scroll indicator at bottom if needed
@@ -344,7 +394,7 @@ q: Quit and finalize"""
             
         # Ensure children are loaded
         if not node.children:
-            self._scan_directory(node.path, node)
+            self._deep_scan_directory_and_calc_size(node.path, node)
             
         # Collect all files recursively
         all_files = []
@@ -353,7 +403,7 @@ q: Quit and finalize"""
             if n.is_dir:
                 # CRITICAL FIX: Ensure sub-directory children are loaded before recursing
                 if not n.children:
-                    self._scan_directory(n.path, n)
+                    self._deep_scan_directory_and_calc_size(n.path, n)
                 for child in n.children:
                     collect_files(child)
             else:
@@ -479,7 +529,7 @@ q: Quit and finalize"""
                         node.expanded = True
                     # Ensure children are loaded
                     if not node.children:
-                        self._scan_directory(node.path, node)
+                        self._deep_scan_directory_and_calc_size(node.path, node)
                     found = True
                     break
             

{kopipasta-0.34.0 → kopipasta-0.35.0/kopipasta.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.34.0
+Version: 0.35.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.34.0 → kopipasta-0.35.0}/setup.py

@@ -10,7 +10,7 @@ with open("requirements.txt", "r", encoding="utf-8") as f:
 
 setup(
     name="kopipasta",
-    version="0.34.0",
+    version="0.35.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.35.0/tests/test_tree_selector.py

@@ -0,0 +1,112 @@
+import os
+import pytest
+from pathlib import Path
+from rich.text import Text
+from kopipasta.file import get_human_readable_size
+from kopipasta.tree_selector import FileNode, 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("a" * 100) # 100 bytes
+    (proj / "README.md").write_text("b" * 200) # 200 bytes
+    
+    sub = proj / "src"
+    sub.mkdir()
+    (sub / "component.js").write_text("c" * 1024) # 1 KB
+    
+    nested_sub = sub / "utils"
+    nested_sub.mkdir()
+    (nested_sub / "helpers.py").write_text("d" * 2048) # 2 KB
+    
+    # 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
+
+
+def test_directory_label_shows_recursive_size_metrics(mock_project: Path):
+    """
+    Tests that directory labels correctly display the total size of selected files
+    and the total size of all files within that directory, recursively.
+    It also checks that the directory selector '○' is removed.
+    """
+    selector = TreeSelector(ignore_patterns=[], project_root_abs=str(mock_project))
+    selector.root = selector.build_tree(["."])
+    selector.root.expanded = True # Expand root to see 'src'
+    
+    # Find the 'src' node and expand it
+    src_node = next(child for child in selector.root.children if child.name == 'src')
+    src_node.expanded = True
+
+    # Pre-select 'main.py' (at root) and 'helpers.py' (nested in src/utils)
+    main_py_abs = os.path.abspath("main.py")
+    helpers_py_abs = os.path.abspath("src/utils/helpers.py")
+    selector.selected_files = {
+        main_py_abs: (False, None),
+        helpers_py_abs: (False, None),
+    }
+
+    # Generate the visible nodes and their labels for testing
+    flat_tree = selector._flatten_tree(selector.root)
+    visible_nodes = [node for node, _ in flat_tree]
+
+    def get_node_label(node: FileNode) -> str:
+        # This is a simplified version of the label generation logic in _build_display_tree
+        # It helps us test the output without a full render cycle.
+        if node.is_dir:
+            total_size, selected_size = selector._calculate_directory_metrics(node)
+            size_str = f" ({get_human_readable_size(selected_size)} / {get_human_readable_size(total_size)})"
+            icon = "📂" if node.expanded else "📁"
+            label = Text()
+            label.append(f"{icon} {node.name}{size_str}")
+            return label.plain
+        return "" # We only care about directory labels for this test
+
+    # Find the nodes we want to test
+    root_node_proxy = visible_nodes[0] # This will be 'src' since we built tree from '.'
+    utils_node = next(n for n in visible_nodes if n.name == 'utils')
+
+    # Test the 'src' directory label
+    # Total: component.js (1024) + helpers.py (2048) = 3072 bytes
+    # Selected: helpers.py (2048) = 2048 bytes
+    src_label = get_node_label(src_node)
+    assert "2.00 KB / 3.00 KB" in src_label
+    assert not src_label.startswith("○")
+
+    # Test the 'utils' directory label
+    # Total: helpers.py (2048) = 2048 bytes
+    # Selected: helpers.py (2048) = 2048 bytes
+    utils_label = get_node_label(utils_node)
+    assert "2.00 KB / 2.00 KB" in utils_label
+    assert not utils_label.startswith("○")

kopipasta-0.34.0/tests/test_tree_selector.py

@@ -1,47 +0,0 @@
-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