x-ipe 1.0.23__py3-none-any.whl → 1.0.25__py3-none-any.whl

x_ipe/services/ideas_service.py

@@ -11,6 +11,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Any
 
+from x_ipe.tracing import x_ipe_tracing
+
 
 class IdeasService:
     """
@@ -48,6 +50,7 @@ class IdeasService:
         self.project_root = Path(project_root).resolve()
         self.ideas_root = self.project_root / self.IDEAS_PATH
     
+    @x_ipe_tracing()
     def get_tree(self) -> List[Dict]:
         """
         Scan x-ipe-docs/ideas/ and return tree structure.
@@ -93,6 +96,7 @@ class IdeasService:
         
         return items
     
+    @x_ipe_tracing()
     def upload(self, files: List[tuple], date: str = None, target_folder: str = None) -> Dict[str, Any]:
         """
         Upload files to a new or existing idea folder.
@@ -155,6 +159,73 @@ class IdeasService:
             'files_uploaded': uploaded_files
         }
     
+    @x_ipe_tracing()
+    def create_folder(self, folder_name: str, parent_folder: str = None) -> Dict[str, Any]:
+        """
+        Create an empty folder in ideas directory.
+        
+        Args:
+            folder_name: Name for the new folder
+            parent_folder: Optional parent folder path (relative to ideas root)
+        
+        Returns:
+            Dict with success, folder_name, folder_path or error
+        """
+        # Validate folder name
+        folder_name = folder_name.strip()
+        is_valid, error = self._validate_folder_name(folder_name)
+        if not is_valid:
+            return {
+                'success': False,
+                'error': error
+            }
+        
+        # Determine base path
+        if parent_folder:
+            # Strip 'x-ipe-docs/ideas/' prefix if present
+            if parent_folder.startswith(self.IDEAS_PATH + '/'):
+                parent_folder = parent_folder[len(self.IDEAS_PATH) + 1:]
+            elif parent_folder.startswith(self.IDEAS_PATH):
+                parent_folder = parent_folder[len(self.IDEAS_PATH):]
+            
+            base_path = self.ideas_root / parent_folder
+            if not base_path.exists():
+                return {
+                    'success': False,
+                    'error': f"Parent folder '{parent_folder}' does not exist"
+                }
+        else:
+            base_path = self.ideas_root
+        
+        # Ensure ideas root exists
+        self.ideas_root.mkdir(parents=True, exist_ok=True)
+        
+        # Generate unique name if folder exists
+        final_name = self._generate_unique_name(folder_name, base_path)
+        
+        # Create the folder
+        folder_path = base_path / final_name
+        try:
+            folder_path.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            return {
+                'success': False,
+                'error': f'Failed to create folder: {str(e)}'
+            }
+        
+        # Build relative path for response
+        if parent_folder:
+            relative_path = f'{self.IDEAS_PATH}/{parent_folder}/{final_name}'
+        else:
+            relative_path = f'{self.IDEAS_PATH}/{final_name}'
+        
+        return {
+            'success': True,
+            'folder_name': final_name,
+            'folder_path': relative_path
+        }
+    
+    @x_ipe_tracing()
     def rename_folder(self, old_name: str, new_name: str) -> Dict[str, Any]:
         """
         Rename an idea folder.
@@ -207,6 +278,7 @@ class IdeasService:
             'new_path': f'{self.IDEAS_PATH}/{final_name}'
         }
     
+    @x_ipe_tracing()
     def rename_file(self, file_path: str, new_name: str) -> Dict[str, Any]:
         """
         Rename a file within x-ipe-docs/ideas/.
@@ -312,20 +384,28 @@ class IdeasService:
         
         return (True, None)
     
-    def _generate_unique_name(self, base_name: str) -> str:
+    def _generate_unique_name(self, base_name: str, base_path: Path = None) -> str:
         """
         Generate unique folder name if base_name exists.
         Appends (2), (3), etc. until unique.
+        
+        Args:
+            base_name: Base name for the folder
+            base_path: Optional base path to check existence (defaults to ideas_root)
         """
+        if base_path is None:
+            base_path = self.ideas_root
+        
         name = base_name
         counter = 2
         
-        while (self.ideas_root / name).exists():
+        while (base_path / name).exists():
             name = f'{base_name} ({counter})'
             counter += 1
         
         return name
     
+    @x_ipe_tracing()
     def delete_item(self, path: str) -> Dict[str, Any]:
         """
         Delete a file or folder within x-ipe-docs/ideas/.
@@ -386,6 +466,7 @@ class IdeasService:
                 'error': f'Failed to delete: {str(e)}'
             }
     
+    @x_ipe_tracing()
     def get_next_version_number(self, folder_path: str, base_name: str = 'idea-summary') -> int:
         """
         Get the next version number for a versioned file.
@@ -414,6 +495,7 @@ class IdeasService:
         
         return max_version + 1
     
+    @x_ipe_tracing()
     def create_versioned_summary(self, folder_path: str, content: str, base_name: str = 'idea-summary') -> Dict[str, Any]:
         """
         Create a new versioned idea summary file.
@@ -472,6 +554,7 @@ class IdeasService:
                 'error': f'Failed to create file: {str(e)}'
             }
     
+    @x_ipe_tracing()
     def get_toolbox(self) -> Dict:
         """
         Read toolbox configuration from JSON file.
@@ -489,6 +572,7 @@ class IdeasService:
                 return copy.deepcopy(self.DEFAULT_TOOLBOX)
         return copy.deepcopy(self.DEFAULT_TOOLBOX)
     
+    @x_ipe_tracing()
     def save_toolbox(self, config: Dict) -> Dict:
         """
         Save toolbox configuration to JSON file.
@@ -510,3 +594,452 @@ class IdeasService:
             return {'success': True}
         except IOError as e:
             return {'success': False, 'error': str(e)}
+    
+    # =========================================================================
+    # CR-006: Folder Tree UX Enhancement
+    # =========================================================================
+    
+    @x_ipe_tracing()
+    def move_item(self, source_path: str, target_folder: str) -> Dict[str, Any]:
+        """
+        Move file or folder to target folder.
+        
+        Args:
+            source_path: Path (relative to project root or ideas root)
+            target_folder: Target folder path (relative to project root or ideas root)
+            
+        Returns:
+            {success: bool, new_path: str, error?: str}
+        """
+        if not source_path:
+            return {'success': False, 'error': 'Source path is required'}
+        if target_folder is None:
+            return {'success': False, 'error': 'Target folder is required'}
+        
+        # Normalize source path - handle both x-ipe-docs/ideas/... and relative paths
+        if source_path.startswith(self.IDEAS_PATH + '/'):
+            source_rel = source_path[len(self.IDEAS_PATH) + 1:]
+        elif source_path.startswith(self.IDEAS_PATH):
+            source_rel = source_path[len(self.IDEAS_PATH):]
+        else:
+            source_rel = source_path
+        source_full = self.ideas_root / source_rel
+        
+        # Normalize target path
+        if target_folder == '' or target_folder == self.IDEAS_PATH:
+            target_full = self.ideas_root
+            target_rel = ''
+        elif target_folder.startswith(self.IDEAS_PATH + '/'):
+            target_rel = target_folder[len(self.IDEAS_PATH) + 1:]
+            target_full = self.ideas_root / target_rel
+        elif target_folder.startswith(self.IDEAS_PATH):
+            target_rel = target_folder[len(self.IDEAS_PATH):]
+            target_full = self.ideas_root / target_rel
+        else:
+            target_rel = target_folder
+            target_full = self.ideas_root / target_folder
+        
+        # Validate source exists
+        if not source_full.exists():
+            return {'success': False, 'error': f'Source not found: {source_path}'}
+        
+        # Validate target exists
+        if not target_full.exists():
+            return {'success': False, 'error': f'Target folder not found: {target_folder}'}
+        
+        # Validate target is a folder
+        if not target_full.is_dir():
+            return {'success': False, 'error': 'Target is not a folder'}
+        
+        # Validate not moving into self or child (use normalized paths)
+        if not self.is_valid_drop_target(source_rel, target_rel):
+            return {'success': False, 'error': 'Cannot move folder into itself or its children'}
+        
+        # Determine destination path
+        dest_path = target_full / source_full.name
+        
+        # Handle name collision
+        if dest_path.exists():
+            dest_path = self._get_unique_path(dest_path)
+        
+        try:
+            shutil.move(str(source_full), str(dest_path))
+            # Return path relative to ideas root
+            new_path = str(dest_path.relative_to(self.ideas_root))
+            return {'success': True, 'new_path': new_path}
+        except OSError as e:
+            return {'success': False, 'error': f'Failed to move: {str(e)}'}
+    
+    @x_ipe_tracing()
+    def duplicate_item(self, path: str) -> Dict[str, Any]:
+        """
+        Duplicate file or folder with -copy suffix.
+        
+        Creates: filename-copy.ext or foldername-copy/
+        If exists: filename-copy-2.ext, etc.
+        """
+        if not path:
+            return {'success': False, 'error': 'Path is required'}
+        
+        # Normalize path
+        if path.startswith(self.IDEAS_PATH + '/'):
+            path_rel = path[len(self.IDEAS_PATH) + 1:]
+        elif path.startswith(self.IDEAS_PATH):
+            path_rel = path[len(self.IDEAS_PATH):]
+        else:
+            path_rel = path
+        
+        full_path = self.ideas_root / path_rel
+        
+        if not full_path.exists():
+            return {'success': False, 'error': f'Path not found: {path}'}
+        
+        # Validate path is within ideas directory
+        try:
+            resolved_path = full_path.resolve()
+            ideas_resolved = self.ideas_root.resolve()
+            
+            if not str(resolved_path).startswith(str(ideas_resolved)):
+                return {'success': False, 'error': 'Path must be within x-ipe-docs/ideas/'}
+        except Exception:
+            return {'success': False, 'error': 'Invalid path'}
+        
+        # Generate copy name
+        if full_path.is_file():
+            stem = full_path.stem
+            suffix = full_path.suffix
+            copy_name = f"{stem}-copy{suffix}"
+            copy_path = full_path.parent / copy_name
+            
+            # Handle collisions
+            counter = 2
+            while copy_path.exists():
+                copy_name = f"{stem}-copy-{counter}{suffix}"
+                copy_path = full_path.parent / copy_name
+                counter += 1
+            
+            try:
+                shutil.copy2(str(full_path), str(copy_path))
+            except OSError as e:
+                return {'success': False, 'error': f'Failed to duplicate: {str(e)}'}
+        else:
+            # Folder
+            copy_name = f"{full_path.name}-copy"
+            copy_path = full_path.parent / copy_name
+            
+            # Handle collisions
+            counter = 2
+            while copy_path.exists():
+                copy_name = f"{full_path.name}-copy-{counter}"
+                copy_path = full_path.parent / copy_name
+                counter += 1
+            
+            try:
+                shutil.copytree(str(full_path), str(copy_path))
+            except OSError as e:
+                return {'success': False, 'error': f'Failed to duplicate: {str(e)}'}
+        
+        # Return path relative to ideas root
+        new_path = str(copy_path.relative_to(self.ideas_root))
+        return {'success': True, 'new_path': new_path}
+    
+    @x_ipe_tracing()
+    def get_folder_contents(self, folder_path: str) -> Dict[str, Any]:
+        """
+        Get contents of a specific folder for folder view panel.
+        
+        Args:
+            folder_path: Path (relative to project root or ideas root)
+            
+        Returns:
+            {success: bool, items: [...], error?: str}
+        """
+        # Normalize path
+        if not folder_path:
+            folder_path_rel = ''
+        elif folder_path.startswith(self.IDEAS_PATH + '/'):
+            folder_path_rel = folder_path[len(self.IDEAS_PATH) + 1:]
+        elif folder_path.startswith(self.IDEAS_PATH):
+            folder_path_rel = folder_path[len(self.IDEAS_PATH):]
+        else:
+            folder_path_rel = folder_path
+        
+        if folder_path_rel:
+            full_path = self.ideas_root / folder_path_rel
+        else:
+            full_path = self.ideas_root
+        
+        if not full_path.exists():
+            return {'success': False, 'error': f'Folder not found: {folder_path}'}
+        
+        if not full_path.is_dir():
+            return {'success': False, 'error': 'Path is not a folder'}
+        
+        # Validate path is within ideas directory
+        try:
+            resolved_path = full_path.resolve()
+            ideas_resolved = self.ideas_root.resolve()
+            
+            if not str(resolved_path).startswith(str(ideas_resolved)):
+                return {'success': False, 'error': 'Path must be within x-ipe-docs/ideas/'}
+        except Exception:
+            return {'success': False, 'error': 'Invalid path'}
+        
+        items = []
+        try:
+            for entry in sorted(full_path.iterdir()):
+                if entry.name.startswith('.'):
+                    continue
+                
+                # Return path relative to project root (consistent with get_tree)
+                relative_path = str(entry.relative_to(self.project_root))
+                item = {
+                    'name': entry.name,
+                    'type': 'folder' if entry.is_dir() else 'file',
+                    'path': relative_path
+                }
+                if entry.is_dir():
+                    item['children'] = []  # Lazy load
+                items.append(item)
+        except PermissionError:
+            return {'success': False, 'error': 'Permission denied'}
+        
+        # Return folder_path relative to project root
+        folder_path_result = str(full_path.relative_to(self.project_root)) if full_path != self.ideas_root else self.IDEAS_PATH
+        return {'success': True, 'items': items, 'folder_path': folder_path_result}
+    
+    @x_ipe_tracing()
+    def is_valid_drop_target(self, source_path: str, target_folder: str) -> bool:
+        """
+        Validate that target is not source or child of source.
+        
+        Args:
+            source_path: Path of item being dragged (relative to ideas root)
+            target_folder: Path of drop target folder (relative to ideas root)
+        """
+        if not source_path:
+            return False
+        
+        # Normalize paths (remove x-ipe-docs/ideas/ prefix if present)
+        if source_path.startswith(self.IDEAS_PATH + '/'):
+            source_norm = source_path[len(self.IDEAS_PATH) + 1:].rstrip('/')
+        elif source_path.startswith(self.IDEAS_PATH):
+            source_norm = source_path[len(self.IDEAS_PATH):].lstrip('/').rstrip('/')
+        else:
+            source_norm = source_path.rstrip('/')
+        
+        if not target_folder:
+            return True  # Root is always valid
+        
+        if target_folder.startswith(self.IDEAS_PATH + '/'):
+            target_norm = target_folder[len(self.IDEAS_PATH) + 1:].rstrip('/')
+        elif target_folder.startswith(self.IDEAS_PATH):
+            target_norm = target_folder[len(self.IDEAS_PATH):].lstrip('/').rstrip('/')
+        else:
+            target_norm = target_folder.rstrip('/')
+        
+        # Cannot drop onto self
+        if source_norm == target_norm:
+            return False
+        
+        # Check if source is a folder
+        source_full = self.ideas_root / source_norm
+        if not source_full.exists() or not source_full.is_dir():
+            return True  # Files can be dropped anywhere, non-existent is handled elsewhere
+        
+        # Cannot drop folder into its own children
+        if target_norm.startswith(source_norm + '/'):
+            return False
+        
+        return True
+    
+    @x_ipe_tracing()
+    def filter_tree(self, query: str) -> List[Dict]:
+        """
+        Filter tree by search query, returning matching items with parent context.
+        
+        Args:
+            query: Search string to match against item names
+            
+        Returns:
+            Flat list of matching items and their parent folders
+        """
+        if not query or not query.strip():
+            return self.get_tree()
+        
+        query_lower = query.lower().strip()
+        tree = self.get_tree()
+        
+        # Collect all matching items plus their parents
+        results = []
+        self._collect_matches(tree, query_lower, results)
+        return results
+    
+    def _collect_matches(self, items: List[Dict], query: str, results: List[Dict], include_all: bool = False) -> bool:
+        """Recursively collect matching items and parents into flat results list.
+        
+        Returns True if any child matches (to include parent in results).
+        """
+        any_match = False
+        
+        for item in items:
+            item_copy = copy.copy(item)
+            name_matches = query in item['name'].lower()
+            
+            if item['type'] == 'folder' and 'children' in item:
+                # Check if any children match
+                child_results = []
+                has_child_match = self._collect_matches(item['children'], query, child_results, include_all=name_matches)
+                
+                if name_matches or has_child_match:
+                    item_copy['_matches'] = name_matches
+                    item_copy['children'] = []  # Don't include nested children in flat result
+                    results.append(item_copy)
+                    results.extend(child_results)
+                    any_match = True
+            else:
+                # File - include if name matches or parent matched
+                if name_matches or include_all:
+                    item_copy['_matches'] = name_matches
+                    results.append(item_copy)
+                    if name_matches:
+                        any_match = True
+        
+        return any_match
+    
+    @x_ipe_tracing()
+    def get_download_info(self, path: str) -> Dict[str, Any]:
+        """
+        Get file content and mime type for download.
+        
+        Args:
+            path: Path (relative to project root or ideas root)
+            
+        Returns:
+            {success: bool, content: bytes, filename: str, mime_type: str}
+        """
+        if not path:
+            return {'success': False, 'error': 'Path is required'}
+        
+        # Normalize path
+        if path.startswith(self.IDEAS_PATH + '/'):
+            path_rel = path[len(self.IDEAS_PATH) + 1:]
+        elif path.startswith(self.IDEAS_PATH):
+            path_rel = path[len(self.IDEAS_PATH):]
+        else:
+            path_rel = path
+        
+        full_path = self.ideas_root / path_rel
+        
+        if not full_path.exists():
+            return {'success': False, 'error': f'File not found: {path}'}
+        
+        if not full_path.is_file():
+            return {'success': False, 'error': 'Cannot download a folder'}
+        
+        # Validate path is within ideas directory
+        try:
+            resolved_path = full_path.resolve()
+            ideas_resolved = self.ideas_root.resolve()
+            
+            if not str(resolved_path).startswith(str(ideas_resolved)):
+                return {'success': False, 'error': 'Path must be within x-ipe-docs/ideas/'}
+        except Exception:
+            return {'success': False, 'error': 'Invalid path'}
+        
+        # Determine mime type
+        suffix = full_path.suffix.lower()
+        mime_types = {
+            '.md': 'text/markdown',
+            '.txt': 'text/plain',
+            '.json': 'application/json',
+            '.html': 'text/html',
+            '.pdf': 'application/pdf',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+        }
+        mime_type = mime_types.get(suffix, 'application/octet-stream')
+        
+        try:
+            content = full_path.read_bytes()
+            # For text files, decode to string for easier testing
+            text_types = ['.md', '.txt', '.json', '.html', '.css', '.js']
+            if suffix in text_types:
+                try:
+                    content = content.decode('utf-8')
+                except UnicodeDecodeError:
+                    pass  # Keep as bytes if decode fails
+            return {
+                'success': True,
+                'content': content,
+                'filename': full_path.name,
+                'mime_type': mime_type
+            }
+        except OSError as e:
+            return {'success': False, 'error': f'Failed to read file: {str(e)}'}
+    
+    @x_ipe_tracing()
+    def get_delete_info(self, path: str) -> Dict[str, Any]:
+        """
+        Get item info for delete confirmation dialog.
+        
+        Returns item type and count of children for folders.
+        """
+        if not path:
+            return {'success': False, 'error': 'Path is required'}
+        
+        # Normalize path
+        if path.startswith(self.IDEAS_PATH + '/'):
+            path_rel = path[len(self.IDEAS_PATH) + 1:]
+        elif path.startswith(self.IDEAS_PATH):
+            path_rel = path[len(self.IDEAS_PATH):]
+        else:
+            path_rel = path
+        
+        full_path = self.ideas_root / path_rel
+        
+        if not full_path.exists():
+            return {'success': False, 'error': f'Path not found: {path}'}
+        
+        item_type = 'folder' if full_path.is_dir() else 'file'
+        item_count = 1
+        
+        if full_path.is_dir():
+            # Count all items recursively
+            item_count = sum(1 for _ in full_path.rglob('*') if not _.name.startswith('.'))
+        
+        return {
+            'success': True,
+            'path': path,
+            'name': full_path.name,
+            'type': item_type,
+            'item_count': item_count
+        }
+    
+    def _get_unique_path(self, path: Path) -> Path:
+        """Generate unique path if target exists."""
+        if not path.exists():
+            return path
+        
+        parent = path.parent
+        if path.is_file() or not path.exists():
+            stem = path.stem
+            suffix = path.suffix
+            counter = 2
+            while True:
+                new_name = f"{stem}-{counter}{suffix}"
+                new_path = parent / new_name
+                if not new_path.exists():
+                    return new_path
+                counter += 1
+        else:
+            name = path.name
+            counter = 2
+            while True:
+                new_name = f"{name}-{counter}"
+                new_path = parent / new_name
+                if not new_path.exists():
+                    return new_path
+                counter += 1