claude-mpm 3.7.4__py3-none-any.whl → 3.7.8__py3-none-any.whl

claude_mpm/dashboard/static/js/components/file-tool-tracker.js

@@ -328,8 +328,20 @@ class FileToolTracker {
      */
     isFileOperation(event) {
         // File operations are tool events with tools that operate on files
-        const fileTools = ['Read', 'Write', 'Edit', 'Grep', 'MultiEdit'];
-        return event.tool_name && fileTools.includes(event.tool_name);
+        // Check case-insensitively since tool names can come in different cases
+        const fileTools = ['read', 'write', 'edit', 'grep', 'multiedit', 'glob', 'ls', 'bash', 'notebookedit'];
+        const toolName = event.tool_name ? event.tool_name.toLowerCase() : '';
+        
+        // Also check if Bash commands involve file operations
+        if (toolName === 'bash' && event.tool_parameters) {
+            const command = event.tool_parameters.command || '';
+            // Check for common file operations in bash commands
+            if (command.match(/\b(cat|less|more|head|tail|touch|mv|cp|rm|mkdir|ls|find)\b/)) {
+                return true;
+            }
+        }
+        
+        return toolName && fileTools.includes(toolName);
     }
 
     /**
@@ -341,11 +353,28 @@ class FileToolTracker {
         // Try various locations where file path might be stored
         if (event.tool_parameters?.file_path) return event.tool_parameters.file_path;
         if (event.tool_parameters?.path) return event.tool_parameters.path;
+        if (event.tool_parameters?.notebook_path) return event.tool_parameters.notebook_path;
         if (event.data?.tool_parameters?.file_path) return event.data.tool_parameters.file_path;
         if (event.data?.tool_parameters?.path) return event.data.tool_parameters.path;
+        if (event.data?.tool_parameters?.notebook_path) return event.data.tool_parameters.notebook_path;
         if (event.file_path) return event.file_path;
         if (event.path) return event.path;
         
+        // For Glob tool, use the pattern as a pseudo-path
+        if (event.tool_name?.toLowerCase() === 'glob' && event.tool_parameters?.pattern) {
+            return `[glob] ${event.tool_parameters.pattern}`;
+        }
+        
+        // For Bash commands, try to extract file paths from the command
+        if (event.tool_name?.toLowerCase() === 'bash' && event.tool_parameters?.command) {
+            const command = event.tool_parameters.command;
+            // Try to extract file paths from common patterns
+            const fileMatch = command.match(/(?:cat|less|more|head|tail|touch|mv|cp|rm|mkdir|ls|find|echo.*>|sed|awk|grep)\s+([^\s;|&]+)/);
+            if (fileMatch && fileMatch[1]) {
+                return fileMatch[1];
+            }
+        }
+        
         return null;
     }
 
@@ -383,7 +412,22 @@ class FileToolTracker {
             case 'write': return 'write';
             case 'edit': return 'edit';
             case 'multiedit': return 'edit';
+            case 'notebookedit': return 'edit';
             case 'grep': return 'search';
+            case 'glob': return 'search';
+            case 'ls': return 'list';
+            case 'bash': 
+                // Check bash command for file operation type
+                const command = event.tool_parameters?.command || '';
+                if (command.match(/\b(cat|less|more|head|tail)\b/)) return 'read';
+                if (command.match(/\b(touch|echo.*>|tee)\b/)) return 'write';
+                if (command.match(/\b(sed|awk)\b/)) return 'edit';
+                if (command.match(/\b(grep|find)\b/)) return 'search';
+                if (command.match(/\b(ls|dir)\b/)) return 'list';
+                if (command.match(/\b(mv|cp)\b/)) return 'copy/move';
+                if (command.match(/\b(rm|rmdir)\b/)) return 'delete';
+                if (command.match(/\b(mkdir)\b/)) return 'create';
+                return 'bash';
             default: return toolName;
         }
     }

claude_mpm/dashboard/templates/index.html

@@ -334,11 +334,11 @@
     <!-- New modular components -->
     <script src="/static/js/components/socket-manager.js"></script>
     <script src="/static/js/components/agent-inference.js"></script>
-    <script src="/static/js/components/ui-state-manager.js"></script>
-    <script src="/static/js/components/working-directory.js"></script>
-    <script src="/static/js/components/file-tool-tracker.js"></script>
-    <script src="/static/js/components/event-processor.js"></script>
-    <script src="/static/js/components/export-manager.js"></script>
+    <script src="/static/js/components/ui-state-manager.js?v=1.0"></script>
+    <script src="/static/js/components/working-directory.js?v=1.0"></script>
+    <script src="/static/js/components/file-tool-tracker.js?v=1.1"></script>
+    <script src="/static/js/components/event-processor.js?v=1.0"></script>
+    <script src="/static/js/components/export-manager.js?v=1.0"></script>
     
     <!-- Main dashboard coordinator -->
     <script src="/static/js/dashboard.js"></script>

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -744,10 +744,14 @@ class AgentDeploymentService:
         agent_id = template_data.get('agent_id', agent_name)
         display_name = template_data.get('metadata', {}).get('name', agent_id)
         
+        # Convert agent_id to Claude Code compatible name (replace underscores with hyphens)
+        # Claude Code requires name to match pattern: ^[a-z0-9]+(-[a-z0-9]+)*$
+        claude_code_name = agent_id.replace('_', '-').lower()
+        
         # Build frontmatter with only the fields Claude Code uses
         frontmatter_lines = [
             "---",
-            f"name: {agent_id}",
+            f"name: {claude_code_name}",
             f"description: {description}",
             f"version: {version_string}",
             f"base_version: {self._format_version_display(base_version)}",

claude_mpm/services/agents/deployment/async_agent_deployment.py

@@ -462,10 +462,14 @@ class AsyncAgentDeploymentService:
         # IMPORTANT: No spaces after commas - Claude Code requires exact format
         tools_str = ','.join(tools) if isinstance(tools, list) else str(tools)
         
+        # Convert agent_id to Claude Code compatible name (replace underscores with hyphens)
+        # Claude Code requires name to match pattern: ^[a-z0-9]+(-[a-z0-9]+)*$
+        claude_code_name = agent_id.replace('_', '-').lower()
+        
         # Build frontmatter with only the fields Claude Code uses
         frontmatter_lines = [
             "---",
-            f"name: {agent_id}",
+            f"name: {claude_code_name}",
             f"description: {description}",
             f"version: {version_string}",
             f"base_version: {self._format_version_display(base_version)}",

claude_mpm/services/agents/management/agent_capabilities_generator.py

@@ -116,9 +116,12 @@ class AgentCapabilitiesGenerator:
             if len(capability_text) > 100:
                 capability_text = capability_text[:97] + '...'
             
+            # Clean up the agent name for TodoWrite usage
+            clean_name = agent['name'].replace(' Agent', '').replace('-', ' ')
+            
             capabilities.append({
-                'name': agent['name'],
-                'id': agent['id'],
+                'name': clean_name,  # Clean name for TodoWrite
+                'id': agent['id'],    # Agent ID for Task tool
                 'capability_text': capability_text,
                 'tools': ', '.join(agent.get('tools', [])[:5])  # First 5 tools
             })
@@ -132,26 +135,33 @@ class AgentCapabilitiesGenerator:
             Configured Jinja2 template
         """
         template_content = """
-## Agent Names & Capabilities
-**Core Agents**: {{ core_agents }}
+## Available Agent Capabilities
+
+You have the following specialized agents available for delegation:
 
 {% if agents_by_tier.project %}
 ### Project-Specific Agents
 {% for agent in agents_by_tier.project %}
-- **{{ agent.name }}** ({{ agent.id }}): {{ agent.description }}
+- **{{ agent.name|replace(' Agent', '')|replace('-', ' ') }}** (`{{ agent.id }}`): {{ agent.description }}
 {% endfor %}
 
 {% endif %}
-**Agent Capabilities**:
+### Engineering Agents
 {% for cap in detailed_capabilities %}
-- **{{ cap.name }}**: {{ cap.capability_text }}
+{% if cap.id in ['engineer', 'data_engineer', 'documentation', 'ops', 'security', 'ticketing', 'version_control', 'web_ui'] %}
+- **{{ cap.name }}** (`{{ cap.id }}`): {{ cap.capability_text }}
+{% endif %}
 {% endfor %}
 
-**Agent Name Formats** (both valid):
-- Capitalized: {{ detailed_capabilities | map(attribute='name') | join('", "') }}
-- Lowercase-hyphenated: {{ detailed_capabilities | map(attribute='id') | join('", "') }}
+### Research Agents
+{% for cap in detailed_capabilities %}
+{% if cap.id in ['code_analyzer', 'qa', 'research', 'web_qa'] %}
+- **{{ cap.name }}** (`{{ cap.id }}`): {{ cap.capability_text }}
+{% endif %}
+{% endfor %}
 
-*Generated from {{ total_agents }} deployed agents*
+**Total Available Agents**: {{ total_agents }}
+Use the agent ID in parentheses when delegating tasks via the Task tool.
 """.strip()
         
         return Template(template_content)

claude_mpm/services/ticket_manager.py

@@ -44,21 +44,28 @@ class TicketManager:
                 (tickets_dir / "tasks").mkdir(exist_ok=True)
                 self.logger.info(f"Created tickets directory structure at: {tickets_dir}")
             
-            # Check if we need to configure ai-trackdown
+            # Use standardized config format (.trackdown.yaml)
             config_file = self.project_path / ".trackdown.yaml"
+            
+            # Check if config exists, create if needed
             if not config_file.exists():
-                # Create default config that uses tickets/ directory
-                config = Config.create_default(config_file)
-                config.set("paths.tickets_dir", "tickets")
-                config.set("paths.epics_dir", "tickets/epics")
-                config.set("paths.issues_dir", "tickets/issues")
-                config.set("paths.tasks_dir", "tickets/tasks")
-                config.save()
-                self.logger.info("Created .trackdown.yaml configuration")
+                try:
+                    config = Config.create_default(str(config_file))
+                    config.set("paths.tickets_dir", "tickets")
+                    config.set("paths.epics_dir", "tickets/epics")
+                    config.set("paths.issues_dir", "tickets/issues")
+                    config.set("paths.tasks_dir", "tickets/tasks")
+                    config.save()
+                    self.logger.info("Created .trackdown.yaml configuration")
+                except Exception as config_error:
+                    self.logger.warning(f"Could not create config file: {config_error}")
+                    self.logger.info("Proceeding without config file - using defaults")
+            else:
+                self.logger.info(f"Using configuration from: {config_file}")
             
             # Initialize TaskManager directly with the project path
             # TaskManager will handle project initialization internally
-            task_manager = TaskManager(self.project_path)
+            task_manager = TaskManager(str(self.project_path))
             
             # Verify it's using the right directory
             if hasattr(task_manager, 'tasks_dir'):
@@ -68,13 +75,41 @@ class TicketManager:
             
             return task_manager
             
-        except ImportError:
-            self.logger.error("ai-trackdown-pytools not installed")
-            self.logger.info("Install with: pip install ai-trackdown-pytools")
+        except ImportError as e:
+            import_msg = str(e)
+            if "ai_trackdown_pytools" in import_msg.lower():
+                self.logger.error("ai-trackdown-pytools is not installed")
+                self.logger.info("Install with: pip install ai-trackdown-pytools")
+            else:
+                self.logger.error(f"Missing dependency: {import_msg}")
+                self.logger.info("Ensure all required packages are installed")
+            self.logger.debug(f"Import error details: {import_msg}")
+            return None
+        except AttributeError as e:
+            attr_msg = str(e)
+            if "TaskManager" in attr_msg:
+                self.logger.error("TaskManager class not found in ai-trackdown-pytools")
+                self.logger.info("This may indicate an incompatible version")
+            else:
+                self.logger.error(f"ai-trackdown-pytools API mismatch: {attr_msg}")
+            self.logger.info("Try updating: pip install --upgrade ai-trackdown-pytools")
+            return None
+        except FileNotFoundError as e:
+            self.logger.error(f"Required file or directory not found: {e}")
+            self.logger.info("Ensure the project directory exists and is accessible")
+            return None
+        except PermissionError as e:
+            self.logger.error(f"Permission denied accessing ticket files: {e}")
+            self.logger.info("Check file permissions in the tickets/ directory")
+            self.logger.info("You may need to run with appropriate permissions")
             return None
         except Exception as e:
-            self.logger.error(f"Failed to initialize TaskManager: {e}")
-            self.logger.debug(f"Error details: {str(e)}", exc_info=True)
+            self.logger.error(f"Unexpected error initializing TaskManager: {e.__class__.__name__}: {e}")
+            self.logger.info("This could be due to:")
+            self.logger.info("  - Corrupted configuration files")
+            self.logger.info("  - Incompatible ai-trackdown-pytools version")
+            self.logger.info("  - Missing dependencies")
+            self.logger.debug(f"Full error details:", exc_info=True)
             return None
     
     def create_ticket(
@@ -96,19 +131,41 @@ class TicketManager:
             title: Ticket title
             ticket_type: Type (task, bug, feature, etc.)
             description: Detailed description
-            priority: Priority level (low, medium, high)
+            priority: Priority level (low, medium, high, critical)
             tags: List of tags/labels
             source: Source identifier
+            parent_epic: Parent epic ID (optional)
+            parent_issue: Parent issue ID (optional)
             **kwargs: Additional metadata
             
         Returns:
             Ticket ID if created, None on failure
         """
         if not self.task_manager:
-            self.logger.error("TaskManager not available")
+            self.logger.error("TaskManager not available - cannot create ticket")
+            self.logger.info("Please ensure ai-trackdown-pytools is installed and properly configured")
+            self.logger.info("Run: pip install ai-trackdown-pytools")
             return None
         
         try:
+            # Validate input
+            if not title or not title.strip():
+                self.logger.error("Cannot create ticket with empty title")
+                return None
+            
+            # Validate priority
+            valid_priorities = ['low', 'medium', 'high', 'critical']
+            if priority.lower() not in valid_priorities:
+                self.logger.warning(f"Invalid priority '{priority}', using 'medium'")
+                self.logger.info(f"Valid priorities are: {', '.join(valid_priorities)}")
+                priority = 'medium'
+            
+            # Validate ticket type
+            valid_types = ['task', 'bug', 'feature', 'issue', 'enhancement', 'documentation']
+            if ticket_type.lower() not in valid_types:
+                self.logger.warning(f"Non-standard ticket type '{ticket_type}'")
+                self.logger.info(f"Common types are: {', '.join(valid_types)}")
+            
             # Prepare tags
             if tags is None:
                 tags = []
@@ -121,7 +178,7 @@ class TicketManager:
             
             # Prepare task data
             task_data = {
-                'title': title,
+                'title': title.strip(),
                 'description': description or f"Auto-extracted {ticket_type} from Claude MPM session",
                 'status': 'open',
                 'priority': priority.lower(),
@@ -136,14 +193,49 @@ class TicketManager:
                 }
             }
             
+            # Add parent references if provided
+            if parent_epic:
+                task_data['metadata']['parent_epic'] = parent_epic
+                self.logger.debug(f"Linking to parent epic: {parent_epic}")
+            if parent_issue:
+                task_data['metadata']['parent_issue'] = parent_issue
+                self.logger.debug(f"Linking to parent issue: {parent_issue}")
+            
             # Create the task
             task = self.task_manager.create_task(**task_data)
             
-            self.logger.info(f"Created ticket: {task.id} - {title}")
-            return task.id
+            if task and hasattr(task, 'id'):
+                self.logger.info(f"Successfully created ticket: {task.id} - {title}")
+                return task.id
+            else:
+                self.logger.error(f"Task creation failed - no ID returned")
+                self.logger.info("The task may have been created but without proper ID assignment")
+                return None
             
+        except AttributeError as e:
+            attr_msg = str(e)
+            if "create_task" in attr_msg:
+                self.logger.error("create_task method not found in TaskManager")
+                self.logger.info("The ai-trackdown-pytools API may have changed")
+                self.logger.info("Check for updates or API documentation")
+            else:
+                self.logger.error(f"API mismatch when creating ticket: {attr_msg}")
+            return None
+        except ValueError as e:
+            self.logger.error(f"Invalid data provided for ticket: {e}")
+            self.logger.info("Check that all required fields are provided correctly")
+            return None
+        except PermissionError as e:
+            self.logger.error(f"Permission denied when creating ticket: {e}")
+            self.logger.info("Check write permissions for the tickets/ directory")
+            return None
         except Exception as e:
-            self.logger.error(f"Failed to create ticket: {e}")
+            self.logger.error(f"Unexpected error creating ticket: {e.__class__.__name__}: {e}")
+            self.logger.info("This could be due to:")
+            self.logger.info("  - Disk full or quota exceeded")
+            self.logger.info("  - Invalid characters in title or description")
+            self.logger.info("  - Network issues (if using remote storage)")
+            self.logger.debug("Full error details:", exc_info=True)
             return None
     
     def list_recent_tickets(self, limit: int = 10) -> List[Dict[str, Any]]:
@@ -157,26 +249,66 @@ class TicketManager:
             List of ticket summaries
         """
         if not self.task_manager:
+            self.logger.warning("TaskManager not available - cannot list tickets")
+            self.logger.info("Run: pip install ai-trackdown-pytools")
             return []
         
         try:
+            # Validate limit
+            if limit < 1:
+                self.logger.warning(f"Invalid limit {limit}, using 10")
+                limit = 10
+            elif limit > 100:
+                self.logger.warning(f"Limit {limit} too high, capping at 100")
+                limit = 100
+            
             tasks = self.task_manager.get_recent_tasks(limit=limit)
             
+            if not tasks:
+                self.logger.info("No tickets found in the system")
+                return []
+            
             tickets = []
             for task in tasks:
-                tickets.append({
-                    'id': task.id,
-                    'title': task.title,
-                    'status': task.status,
-                    'priority': task.priority,
-                    'tags': task.tags,
-                    'created_at': task.created_at,
-                })
+                try:
+                    ticket_data = {
+                        'id': getattr(task, 'id', 'UNKNOWN'),
+                        'title': getattr(task, 'title', 'Untitled'),
+                        'status': getattr(task, 'status', 'unknown'),
+                        'priority': getattr(task, 'priority', 'medium'),
+                        'tags': getattr(task, 'tags', []),
+                        'created_at': getattr(task, 'created_at', 'N/A'),
+                    }
+                    tickets.append(ticket_data)
+                except Exception as task_error:
+                    self.logger.warning(f"Error processing task: {task_error}")
+                    self.logger.debug(f"Task object type: {type(task)}")
+                    continue
             
+            self.logger.info(f"Retrieved {len(tickets)} tickets")
             return tickets
             
+        except AttributeError as e:
+            attr_msg = str(e)
+            if "get_recent_tasks" in attr_msg:
+                self.logger.error("get_recent_tasks method not found in TaskManager")
+                self.logger.info("This method may not be available in your version")
+                self.logger.info("Try using the CLI directly: aitrackdown task list")
+            else:
+                self.logger.error(f"API mismatch when listing tickets: {attr_msg}")
+            return []
+        except FileNotFoundError as e:
+            self.logger.error(f"Tickets directory not found: {e}")
+            self.logger.info("Ensure the tickets/ directory exists")
+            return []
+        except PermissionError as e:
+            self.logger.error(f"Permission denied reading tickets: {e}")
+            self.logger.info("Check read permissions for the tickets/ directory")
+            return []
         except Exception as e:
-            self.logger.error(f"Failed to list tickets: {e}")
+            self.logger.error(f"Failed to list tickets: {e.__class__.__name__}: {e}")
+            self.logger.info("Try using the CLI directly: aitrackdown task list")
+            self.logger.debug("Full error details:", exc_info=True)
             return []
     
     def get_ticket(self, ticket_id: str) -> Optional[Dict[str, Any]]:
@@ -190,24 +322,55 @@ class TicketManager:
             Ticket data or None
         """
         if not self.task_manager:
+            self.logger.error("TaskManager not available - cannot retrieve ticket")
+            self.logger.info("Run: pip install ai-trackdown-pytools")
+            return None
+        
+        if not ticket_id or not ticket_id.strip():
+            self.logger.error("Invalid ticket ID provided")
             return None
         
         try:
-            task = self.task_manager.load_task(ticket_id)
-            
-            return {
-                'id': task.id,
-                'title': task.title,
-                'description': task.description,
-                'status': task.status,
-                'priority': task.priority,
-                'tags': task.tags,
-                'assignees': task.assignees,
-                'created_at': task.created_at,
-                'updated_at': task.updated_at,
-                'metadata': task.metadata,
+            task = self.task_manager.load_task(ticket_id.strip())
+            
+            if not task:
+                self.logger.warning(f"Ticket {ticket_id} not found")
+                return None
+            
+            # Safely extract all fields with defaults
+            ticket_data = {
+                'id': getattr(task, 'id', ticket_id),
+                'title': getattr(task, 'title', 'Untitled'),
+                'description': getattr(task, 'description', ''),
+                'status': getattr(task, 'status', 'unknown'),
+                'priority': getattr(task, 'priority', 'medium'),
+                'tags': getattr(task, 'tags', []),
+                'assignees': getattr(task, 'assignees', []),
+                'created_at': getattr(task, 'created_at', 'N/A'),
+                'updated_at': getattr(task, 'updated_at', 'N/A'),
+                'metadata': getattr(task, 'metadata', {}),
             }
             
+            self.logger.info(f"Successfully retrieved ticket: {ticket_id}")
+            return ticket_data
+            
+        except AttributeError as e:
+            attr_msg = str(e)
+            if "load_task" in attr_msg:
+                self.logger.error("load_task method not found in TaskManager")
+                self.logger.info("The API may have changed or this method is not available")
+            else:
+                self.logger.error(f"Error accessing ticket attributes: {attr_msg}")
+            return None
+        except FileNotFoundError as e:
+            self.logger.error(f"Ticket file not found: {ticket_id}")
+            self.logger.info(f"The ticket may have been deleted or the ID is incorrect")
+            return None
+        except PermissionError as e:
+            self.logger.error(f"Permission denied reading ticket {ticket_id}: {e}")
+            return None
         except Exception as e:
-            self.logger.error(f"Failed to get ticket {ticket_id}: {e}")
+            self.logger.error(f"Failed to get ticket {ticket_id}: {e.__class__.__name__}: {e}")
+            self.logger.info(f"Try using the CLI: aitrackdown show {ticket_id}")
+            self.logger.debug("Full error details:", exc_info=True)
             return None

claude_mpm/utils/agent_dependency_loader.py

@@ -278,7 +278,11 @@ class AgentDependencyLoader:
     
     def install_missing_dependencies(self, dependencies: List[str]) -> Tuple[bool, str]:
         """
-        Install missing Python dependencies.
+        Install missing Python dependencies using robust retry logic.
+        
+        WHY: Network issues and temporary package unavailability can cause
+        installation failures. Using the robust installer with retries
+        significantly improves success rate.
         
         Args:
             dependencies: List of package specifications to install
@@ -299,27 +303,74 @@ class AgentDependencyLoader:
         
         if not compatible:
             return True, "No compatible packages to install"
-            
+        
+        # Use robust installer with retry logic
         try:
-            cmd = [sys.executable, "-m", "pip", "install"] + compatible
-            logger.info(f"Installing {len(compatible)} compatible dependencies...")
+            from .robust_installer import RobustPackageInstaller
+            
+            logger.info(f"Installing {len(compatible)} compatible dependencies with retry logic...")
             if incompatible:
                 logger.info(f"(Skipping {len(incompatible)} incompatible with Python {sys.version_info.major}.{sys.version_info.minor})")
             
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
+            # Create installer with sensible defaults
+            installer = RobustPackageInstaller(
+                max_retries=3,
+                retry_delay=2.0,
                 timeout=300
             )
             
-            if result.returncode == 0:
-                logger.info("Successfully installed compatible dependencies")
-                if incompatible:
-                    return True, f"Installed {len(compatible)} packages, skipped {len(incompatible)} incompatible"
-                return True, ""
-            else:
-                error_msg = f"Installation failed: {result.stderr}"
+            # Install packages
+            successful, failed, errors = installer.install_packages(compatible)
+            
+            if failed:
+                # Provide detailed error information
+                error_details = []
+                for pkg in failed:
+                    error_details.append(f"{pkg}: {errors.get(pkg, 'Unknown error')}")
+                
+                error_msg = f"Failed to install {len(failed)} packages:\n" + "\n".join(error_details)
+                logger.error(error_msg)
+                
+                # Partial success handling
+                if successful:
+                    partial_msg = f"Partially successful: installed {len(successful)} of {len(compatible)} packages"
+                    logger.info(partial_msg)
+                    if incompatible:
+                        return True, f"{partial_msg}. Also skipped {len(incompatible)} incompatible"
+                    return True, partial_msg
+                
+                return False, error_msg
+            
+            logger.info(f"Successfully installed all {len(successful)} compatible dependencies")
+            if incompatible:
+                return True, f"Installed {len(compatible)} packages, skipped {len(incompatible)} incompatible"
+            return True, ""
+            
+        except ImportError:
+            # Fallback to simple installation if robust installer not available
+            logger.warning("Robust installer not available, falling back to simple installation")
+            try:
+                cmd = [sys.executable, "-m", "pip", "install"] + compatible
+                
+                result = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    timeout=300
+                )
+                
+                if result.returncode == 0:
+                    logger.info("Successfully installed compatible dependencies")
+                    if incompatible:
+                        return True, f"Installed {len(compatible)} packages, skipped {len(incompatible)} incompatible"
+                    return True, ""
+                else:
+                    error_msg = f"Installation failed: {result.stderr}"
+                    logger.error(error_msg)
+                    return False, error_msg
+                    
+            except Exception as e:
+                error_msg = f"Failed to install dependencies: {e}"
                 logger.error(error_msg)
                 return False, error_msg