portacode 0.3.19.dev7__tar.gz → 0.3.19.dev9__tar.gz

{portacode-0.3.19.dev7 → portacode-0.3.19.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: portacode
-Version: 0.3.19.dev7
+Version: 0.3.19.dev9
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-0.3.19.dev7 → portacode-0.3.19.dev9}/portacode/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.19.dev7'
-__version_tuple__ = version_tuple = (0, 3, 19, 'dev7')
+__version__ = version = '0.3.19.dev9'
+__version_tuple__ = version_tuple = (0, 3, 19, 'dev9')

{portacode-0.3.19.dev7 → portacode-0.3.19.dev9}/portacode/connection/handlers/project_state_handlers.py

@@ -300,9 +300,18 @@ class GitManager:
             logger.debug("diff-match-patch not available, skipping diff details computation")
             return None
         
+        # Add performance safeguards to prevent blocking
+        max_content_size = 50000  # 50KB max per file for diff details
+        if len(original_content) > max_content_size or len(modified_content) > max_content_size:
+            logger.debug("File too large for diff details computation")
+            return None
+        
         try:
             dmp = diff_match_patch()
             
+            # Set timeout for diff computation
+            dmp.Diff_Timeout = 1.0  # 1 second timeout
+            
             # Compute the diff
             diffs = dmp.diff_main(original_content, modified_content)
             
@@ -344,7 +353,8 @@ class GitManager:
         
         try:
             # Use Pygments' built-in filename detection
-            return get_lexer_for_filename(file_path)
+            lexer = get_lexer_for_filename(file_path)
+            return lexer
         except ClassNotFound:
             # If no lexer found, return None (will fall back to plain text)
             logger.debug("No Pygments lexer found for file: %s", file_path)
@@ -359,14 +369,38 @@ class GitManager:
             logger.debug("Pygments not available for HTML diff generation")
             return None
         
+        # Add performance safeguards to prevent blocking
+        max_content_size = 100000  # 100KB max per file
+        max_lines = 1000  # Max 1000 lines per file
+        
+        if len(original_content) > max_content_size or len(modified_content) > max_content_size:
+            logger.warning(f"File too large for diff generation: {file_path}")
+            return None
+            
+        original_line_count = original_content.count('\n')
+        modified_line_count = modified_content.count('\n')
+        
+        if original_line_count > max_lines or modified_line_count > max_lines:
+            logger.warning(f"Too many lines for diff generation: {file_path} ({max(original_line_count, modified_line_count)} lines)")
+            return None
+        
         try:
             import difflib
+            import time
+            
+            start_time = time.time()
+            timeout_seconds = 5  # 5 second timeout
             
             # Get line-based diff using Python's difflib (similar to git diff)
             original_lines = original_content.splitlines(keepends=True)
             modified_lines = modified_content.splitlines(keepends=True)
             
-            # Generate both minimal (3 lines context) and full context diffs
+            # Check timeout
+            if time.time() - start_time > timeout_seconds:
+                logger.warning(f"Diff generation timeout for {file_path}")
+                return None
+            
+            # Generate minimal diff only to improve performance
             minimal_diff_lines = list(difflib.unified_diff(
                 original_lines, 
                 modified_lines, 
@@ -376,34 +410,96 @@ class GitManager:
                 n=3  # 3 lines of context (default)
             ))
             
-            full_diff_lines = list(difflib.unified_diff(
-                original_lines, 
-                modified_lines, 
-                fromfile='a/' + os.path.basename(file_path),
-                tofile='b/' + os.path.basename(file_path),
-                lineterm='',
-                n=len(original_lines) + len(modified_lines)  # Show all lines
-            ))
+            # Check timeout again
+            if time.time() - start_time > timeout_seconds:
+                logger.warning(f"Diff generation timeout for {file_path}")
+                return None
+            
+            # Parse diff (simplified - no intraline processing to improve performance)
+            minimal_parsed = self._parse_unified_diff_simple(minimal_diff_lines)
             
-            # Parse both diffs
-            minimal_parsed = self._parse_unified_diff_with_intraline(minimal_diff_lines, original_lines, modified_lines)
-            full_parsed = self._parse_unified_diff_with_intraline(full_diff_lines, original_lines, modified_lines)
+            # Check timeout
+            if time.time() - start_time > timeout_seconds:
+                logger.warning(f"Diff generation timeout for {file_path}")
+                return None
             
-            # Generate HTML for both versions
+            # Generate HTML for minimal version only
             minimal_html = self._generate_diff_html(minimal_parsed, file_path, 'minimal')
-            full_html = self._generate_diff_html(full_parsed, file_path, 'full')
             
             return {
                 'minimal': minimal_html,
-                'full': full_html
+                'full': minimal_html  # Use same for both to improve performance
             }
             
         except Exception as e:
             logger.error("Error generating HTML diff: %s", e)
             return None
     
+    def _parse_unified_diff_simple(self, diff_lines):
+        """Simple unified diff parser without intra-line highlighting for better performance."""
+        parsed = []
+        old_line_num = 0
+        new_line_num = 0
+        
+        for line in diff_lines:
+            if line.startswith('@@'):
+                # Parse hunk header to get line numbers
+                import re
+                match = re.match(r'@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@', line)
+                if match:
+                    old_line_num = int(match.group(1)) - 1
+                    new_line_num = int(match.group(2)) - 1
+                
+                parsed.append({
+                    'type': 'header',
+                    'content': line,
+                    'old_line_num': '',
+                    'new_line_num': ''
+                })
+            elif line.startswith('---') or line.startswith('+++'):
+                # Skip diff file headers (--- a/file, +++ b/file)
+                parsed.append({
+                    'type': 'header',
+                    'content': line,
+                    'old_line_num': '',
+                    'new_line_num': ''
+                })
+            elif line.startswith('-'):
+                old_line_num += 1
+                parsed.append({
+                    'type': 'delete',
+                    'old_line_num': old_line_num,
+                    'new_line_num': '',
+                    'content': line
+                })
+            elif line.startswith('+'):
+                new_line_num += 1
+                parsed.append({
+                    'type': 'add',
+                    'old_line_num': '',
+                    'new_line_num': new_line_num,
+                    'content': line
+                })
+            elif line.startswith(' '):
+                old_line_num += 1
+                new_line_num += 1
+                parsed.append({
+                    'type': 'context',
+                    'old_line_num': old_line_num,
+                    'new_line_num': new_line_num,
+                    'content': line
+                })
+        
+        return parsed
+    
     def _generate_diff_html(self, parsed_diff: List[Dict], file_path: str, view_mode: str) -> str:
         """Generate HTML for a parsed diff."""
+        # Limit diff size to prevent performance issues
+        max_diff_lines = 200
+        if len(parsed_diff) > max_diff_lines:
+            logger.warning(f"Diff too large, truncating: {file_path} ({len(parsed_diff)} lines)")
+            parsed_diff = parsed_diff[:max_diff_lines]
+        
         # Get Pygments lexer for syntax highlighting
         lexer = self._get_pygments_lexer(file_path)
         
@@ -443,44 +539,40 @@ class GitManager:
             old_line_num = line_info.get('old_line_num', '')
             new_line_num = line_info.get('new_line_num', '')
             content = line_info['content']
-            intraline_html = line_info.get('intraline_html', '')
             
-            # Use intra-line highlighted content if available
-            if intraline_html:
-                final_content = intraline_html
-            else:
-                # Apply syntax highlighting to the content
-                if content and content[0] in '+-':
-                    # For added/deleted lines, highlight the content without the prefix
-                    prefix = content[0]
-                    clean_content = content[1:]
-                    
-                    if lexer and clean_content.strip():
-                        try:
-                            # Apply syntax highlighting
-                            highlighted = highlight(clean_content, lexer, HtmlFormatter(nowrap=True, noclasses=False))
-                            final_content = prefix + highlighted
-                        except Exception as e:
-                            logger.debug("Error applying syntax highlighting: %s", e)
-                            final_content = self._escape_html(content)
-                    else:
+            # Apply syntax highlighting to the content
+            if content and content[0] in '+-':
+                # For added/deleted lines, highlight the content without the prefix
+                prefix = content[0]
+                clean_content = content[1:]
+                
+                if lexer and clean_content.strip():
+                    try:
+                        # Apply syntax highlighting using Monokai theme to match ACE editor
+                        highlighted = highlight(clean_content, lexer, HtmlFormatter(nowrap=True, noclasses=False, style='monokai'))
+                        final_content = prefix + highlighted
+                    except Exception as e:
+                        logger.debug("Error applying syntax highlighting: %s", e)
                         final_content = self._escape_html(content)
-                elif content and content[0] == ' ':
-                    # For context lines, highlight without the space prefix
-                    clean_content = content[1:]
-                    
-                    if lexer and clean_content.strip():
-                        try:
-                            # Apply syntax highlighting
-                            highlighted = highlight(clean_content, lexer, HtmlFormatter(nowrap=True, noclasses=False))
-                            final_content = ' ' + highlighted
-                        except Exception as e:
-                            logger.debug("Error applying syntax highlighting: %s", e)
-                            final_content = self._escape_html(content)
-                    else:
+                else:
+                    final_content = self._escape_html(content)
+                
+            elif content and content[0] == ' ':
+                # For context lines, highlight without the space prefix
+                clean_content = content[1:]
+                
+                if lexer and clean_content.strip():
+                    try:
+                        # Apply syntax highlighting using Monokai theme to match ACE editor
+                        highlighted = highlight(clean_content, lexer, HtmlFormatter(nowrap=True, noclasses=False, style='monokai'))
+                        final_content = ' ' + highlighted
+                    except Exception as e:
+                        logger.debug("Error applying syntax highlighting: %s", e)
                         final_content = self._escape_html(content)
                 else:
                     final_content = self._escape_html(content)
+            else:
+                final_content = self._escape_html(content)
             
             # CSS classes for different line types
             row_class = f'diff-line diff-{line_type}'
@@ -550,6 +642,14 @@ class GitManager:
                     old_line_num = int(match.group(1)) - 1
                     new_line_num = int(match.group(2)) - 1
                 
+                parsed.append({
+                    'type': 'header',
+                    'content': line,
+                    'old_line_num': '',
+                    'new_line_num': ''
+                })
+            elif line.startswith('---') or line.startswith('+++'):
+                # Skip diff file headers (--- a/file, +++ b/file)
                 parsed.append({
                     'type': 'header',
                     'content': line,
@@ -599,6 +699,9 @@ class GitManager:
     
     def _generate_intraline_diff(self, old_text: str, new_text: str) -> Tuple[str, str]:
         """Generate intra-line character-level diff highlighting."""
+        # Temporarily disable intraline highlighting to fix performance issues
+        return self._escape_html(old_text), self._escape_html(new_text)
+        
         if not DIFF_MATCH_PATCH_AVAILABLE:
             return self._escape_html(old_text), self._escape_html(new_text)
         
@@ -1563,7 +1666,13 @@ class ProjectStateManager:
             diff_details = git_manager._compute_diff_details(original_content, modified_content)
             
             # Generate HTML diff with syntax highlighting (both minimal and full context)
-            html_diff_versions = git_manager._generate_html_diff(original_content, modified_content, file_path)
+            # Wrap in try-catch to prevent blocking the WebSocket handler
+            html_diff_versions = None
+            try:
+                html_diff_versions = git_manager._generate_html_diff(original_content, modified_content, file_path)
+            except Exception as e:
+                logger.error(f"Error generating HTML diff for {file_path}: {e}")
+                # Continue without HTML diff - fallback to basic diff will be used
             
             # Create a descriptive title for the diff
             title_parts = []
@@ -1585,14 +1694,19 @@ class ProjectStateManager:
             )
             
             # Add metadata about the diff references
-            diff_tab.metadata.update({
+            metadata_update = {
                 'from_ref': from_ref,
                 'to_ref': to_ref,
                 'from_hash': from_hash,
                 'to_hash': to_hash,
-                'diff_timeline': True,
-                'html_diff_versions': html_diff_versions
-            })
+                'diff_timeline': True
+            }
+            
+            # Only add HTML diff versions if they were successfully generated
+            if html_diff_versions:
+                metadata_update['html_diff_versions'] = html_diff_versions
+            
+            diff_tab.metadata.update(metadata_update)
             
             project_state.open_tabs[tab_key] = diff_tab
             project_state.active_tab = diff_tab

{portacode-0.3.19.dev7 → portacode-0.3.19.dev9}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: portacode
-Version: 0.3.19.dev7
+Version: 0.3.19.dev9
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian