claude-mpm 5.4.55__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/cli/commands/configure.py

@@ -26,6 +26,7 @@ from rich.prompt import Confirm, Prompt
 from rich.text import Text
 
 from ...core.config import Config
+from ...core.unified_config import UnifiedConfig
 from ...services.agents.agent_recommendation_service import AgentRecommendationService
 from ...services.version_service import VersionService
 from ...utils.agent_filters import apply_all_filters, get_deployed_agent_ids
@@ -79,6 +80,7 @@ class ConfigureCommand(BaseCommand):
         self._template_editor = None  # Lazy-initialized
         self._startup_manager = None  # Lazy-initialized
         self._recommendation_service = None  # Lazy-initialized
+        self._unified_config = None  # Lazy-initialized
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
@@ -162,6 +164,18 @@ class ConfigureCommand(BaseCommand):
             self._recommendation_service = AgentRecommendationService()
         return self._recommendation_service
 
+    @property
+    def unified_config(self) -> UnifiedConfig:
+        """Lazy-initialize unified config."""
+        if self._unified_config is None:
+            try:
+                self._unified_config = UnifiedConfig()
+            except Exception as e:
+                self.logger.warning(f"Failed to load unified config: {e}")
+                # Fallback to default config
+                self._unified_config = UnifiedConfig()
+        return self._unified_config
+
     def run(self, args) -> CommandResult:
         """Execute the configure command."""
         # Set configuration scope
@@ -656,7 +670,7 @@ class ConfigureCommand(BaseCommand):
         self.behavior_manager.manage_behaviors()
 
     def _manage_skills(self) -> None:
-        """Skills management interface."""
+        """Skills management interface with questionary checkbox selection."""
         from ...cli.interactive.skills_wizard import SkillsWizard
         from ...skills.skill_manager import get_manager
 
@@ -667,22 +681,22 @@ class ConfigureCommand(BaseCommand):
             self.console.clear()
             self._display_header()
 
-            self.console.print("\n[bold]Skills Management Options:[/bold]\n")
-            self.console.print("  [1] View Available Skills")
-            self.console.print("  [2] Configure Skills for Agents")
-            self.console.print("  [3] View Current Skill Mappings")
-            self.console.print("  [4] Auto-Link Skills to Agents")
-            self.console.print("  [b] Back to Main Menu")
+            self.console.print("\n[bold]Skills Management[/bold]")
+
+            # Show action options
+            self.console.print("\n[bold]Actions:[/bold]")
+            self.console.print("  [1] Install/Uninstall skills")
+            self.console.print("  [2] Configure skills for agents")
+            self.console.print("  [3] View current skill mappings")
+            self.console.print("  [4] Auto-link skills to agents")
+            self.console.print("  [b] Back to main menu")
             self.console.print()
 
             choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
 
             if choice == "1":
-                # View available skills
-                self.console.clear()
-                self._display_header()
-                wizard.list_available_skills()
-                Prompt.ask("\nPress Enter to continue")
+                # Install/Uninstall skills with category-based selection
+                self._manage_skill_installation()
 
             elif choice == "2":
                 # Configure skills interactively
@@ -805,6 +819,548 @@ class ConfigureCommand(BaseCommand):
                 self.console.print("[red]Invalid choice. Please try again.[/red]")
                 Prompt.ask("\nPress Enter to continue")
 
+    def _detect_skill_patterns(self, skills: list[dict]) -> dict[str, list[dict]]:
+        """Group skills by detected common prefixes.
+
+        Args:
+            skills: List of skill dictionaries
+
+        Returns:
+            Dict mapping pattern prefix to list of skills.
+            Skills without pattern match go under "" (empty string) key.
+        """
+        from collections import defaultdict
+
+        # Count prefix occurrences (try 1-segment and 2-segment prefixes)
+        prefix_counts = defaultdict(list)
+
+        for skill in skills:
+            skill_id = skill.get("name", skill.get("skill_id", ""))
+
+            # Try to extract prefixes (split by hyphen)
+            parts = skill_id.split("-")
+
+            if len(parts) >= 2:
+                # Try 2-segment prefix first (e.g., "toolchains-universal")
+                two_seg_prefix = f"{parts[0]}-{parts[1]}"
+                prefix_counts[two_seg_prefix].append(skill)
+
+                # Also try 1-segment prefix (e.g., "digitalocean")
+                one_seg_prefix = parts[0]
+                if one_seg_prefix != two_seg_prefix:
+                    prefix_counts[one_seg_prefix].append(skill)
+
+        # Build pattern groups (require at least 2 skills per pattern)
+        pattern_groups = defaultdict(list)
+        used_skills = set()
+
+        # Prefer longer (more specific) prefixes
+        sorted_prefixes = sorted(prefix_counts.keys(), key=lambda x: (-len(x), x))
+
+        for prefix in sorted_prefixes:
+            matching_skills = prefix_counts[prefix]
+
+            # Only create a pattern group if we have 2+ skills and they're not already grouped
+            available_skills = [s for s in matching_skills if id(s) not in used_skills]
+
+            if len(available_skills) >= 2:
+                pattern_groups[prefix] = available_skills
+                used_skills.update(id(s) for s in available_skills)
+
+        # Add ungrouped skills to "" (Other) group
+        for skill in skills:
+            if id(skill) not in used_skills:
+                pattern_groups[""].append(skill)
+
+        return dict(pattern_groups)
+
+    def _get_pattern_icon(self, prefix: str) -> str:
+        """Get icon for a pattern prefix.
+
+        Args:
+            prefix: Pattern prefix (e.g., "digitalocean", "vercel")
+
+        Returns:
+            Emoji icon for the pattern
+        """
+        pattern_icons = {
+            "digitalocean": "🌊",
+            "aws": "☁️",
+            "github": "🐙",
+            "google": "🔍",
+            "vercel": "▲",
+            "netlify": "🦋",
+            "universal-testing": "🧪",
+            "universal-debugging": "🐛",
+            "universal-security": "🔒",
+            "toolchains-python": "🐍",
+            "toolchains-typescript": "📘",
+            "toolchains-javascript": "📒",
+        }
+        return pattern_icons.get(prefix, "📦")
+
+    def _manage_skill_installation(self) -> None:
+        """Manage skill installation with category-based questionary checkbox selection."""
+        import questionary
+
+        # Get all skills
+        all_skills = self._get_all_skills_from_git()
+        if not all_skills:
+            self.console.print(
+                "[yellow]No skills available. Try syncing skills first.[/yellow]"
+            )
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Get deployed skills
+        deployed = self._get_deployed_skill_ids()
+
+        # Group by category
+        grouped = {}
+        for skill in all_skills:
+            # Try to get category from tags or use toolchain
+            category = None
+            tags = skill.get("tags", [])
+
+            # Look for category tag
+            for tag in tags:
+                if tag in [
+                    "universal",
+                    "python",
+                    "typescript",
+                    "javascript",
+                    "go",
+                    "rust",
+                ]:
+                    category = tag
+                    break
+
+            # Fallback to toolchain or universal
+            if not category:
+                category = skill.get("toolchain", "universal")
+
+            if category not in grouped:
+                grouped[category] = []
+            grouped[category].append(skill)
+
+        # Category icons
+        icons = {
+            "universal": "🌐",
+            "python": "🐍",
+            "typescript": "📘",
+            "javascript": "📒",
+            "go": "🔷",
+            "rust": "⚙️",
+        }
+
+        # Sort categories: universal first, then alphabetically
+        categories = sorted(grouped.keys(), key=lambda x: (x != "universal", x))
+
+        while True:
+            # Show category selection first
+            self.console.clear()
+            self._display_header()
+            self.console.print("\n[bold cyan]Skills Management[/bold cyan]")
+            self.console.print(
+                f"[dim]{len(all_skills)} skills available, {len(deployed)} installed[/dim]\n"
+            )
+
+            cat_choices = [
+                Choice(
+                    title=f"{icons.get(cat, '📦')} {cat.title()} ({len(grouped[cat])} skills)",
+                    value=cat,
+                )
+                for cat in categories
+            ]
+            cat_choices.append(Choice(title="← Back to main menu", value="back"))
+
+            selected_cat = questionary.select(
+                "Select a category:", choices=cat_choices, style=self.QUESTIONARY_STYLE
+            ).ask()
+
+            if selected_cat is None or selected_cat == "back":
+                return
+
+            # Show skills in category with checkbox selection
+            category_skills = grouped[selected_cat]
+
+            # Detect pattern groups within category
+            pattern_groups = self._detect_skill_patterns(category_skills)
+
+            # Build choices with pattern grouping and installation status
+            skill_choices = []
+
+            # Track which skills belong to which group for expansion later
+            group_to_skills = {}
+
+            # Sort pattern groups: "" (Other) last, rest alphabetically
+            sorted_patterns = sorted(pattern_groups.keys(), key=lambda x: (x == "", x))
+
+            for pattern in sorted_patterns:
+                pattern_skills = pattern_groups[pattern]
+
+                # Skip empty groups
+                if not pattern_skills:
+                    continue
+
+                # Collect skill IDs in this group
+                skill_ids_in_group = []
+                for skill in pattern_skills:
+                    skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                    skill_ids_in_group.append(skill_id)
+
+                # Check if all skills in group are installed
+                all_installed = all(
+                    skill.get(
+                        "deployment_name", skill.get("name", skill.get("skill_id"))
+                    )
+                    in deployed
+                    or skill.get("name", skill.get("skill_id")) in deployed
+                    for skill in pattern_skills
+                )
+
+                # Add pattern group header as selectable choice
+                if pattern:
+                    # Named pattern group
+                    pattern_icon = self._get_pattern_icon(pattern)
+                    skill_count = len(pattern_skills)
+                    group_key = f"__group__:{pattern}"
+                    group_to_skills[group_key] = skill_ids_in_group
+
+                    skill_choices.append(
+                        Choice(
+                            title=f"{pattern_icon} {pattern} ({skill_count} skills) [Select All]",
+                            value=group_key,
+                            checked=all_installed,
+                        )
+                    )
+                elif pattern_skills:
+                    # "Other" group - only show if there are skills
+                    group_key = "__group__:Other"
+                    group_to_skills[group_key] = skill_ids_in_group
+
+                    skill_choices.append(
+                        Choice(
+                            title=f"📦 Other ({len(pattern_skills)} skills) [Select All]",
+                            value=group_key,
+                            checked=all_installed,
+                        )
+                    )
+
+                # Add skills in this pattern group
+                for skill in sorted(pattern_skills, key=lambda x: x.get("name", "")):
+                    skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                    deploy_name = skill.get("deployment_name", skill_id)
+                    description = skill.get("description", "")[:50]
+
+                    # Check if installed
+                    is_installed = deploy_name in deployed or skill_id in deployed
+
+                    # Add indentation for pattern-grouped skills (all skills are indented)
+                    skill_choices.append(
+                        Choice(
+                            title=f"    {skill_id} - {description}",
+                            value=skill_id,
+                            checked=is_installed,
+                        )
+                    )
+
+                # Add spacing between pattern groups (not after last group)
+                if pattern != sorted_patterns[-1]:
+                    skill_choices.append(Separator())
+
+            self.console.clear()
+            self._display_header()
+            self.console.print(
+                f"\n{icons.get(selected_cat, '📦')} [bold]{selected_cat.title()}[/bold]"
+            )
+            self.console.print(
+                "[dim]Use spacebar to toggle individual skills or entire groups, enter to confirm[/dim]\n"
+            )
+
+            selected = questionary.checkbox(
+                "Select skills to install:",
+                choices=skill_choices,
+                style=self.QUESTIONARY_STYLE,
+            ).ask()
+
+            if selected is None:
+                continue  # User cancelled, go back to category selection
+
+            # Process group selections - expand to individual skills
+            selected_set = set()
+            for item in selected:
+                if item.startswith("__group__:"):
+                    # Expand group selection to all skills in that group
+                    selected_set.update(group_to_skills[item])
+                else:
+                    # Individual skill selection
+                    selected_set.add(item)
+
+            current_in_cat = set()
+
+            # Find currently installed skills in this category
+            for skill in category_skills:
+                skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                deploy_name = skill.get("deployment_name", skill_id)
+                if deploy_name in deployed or skill_id in deployed:
+                    current_in_cat.add(skill_id)
+
+            # Install newly selected
+            to_install = selected_set - current_in_cat
+            for skill_id in to_install:
+                skill = next(
+                    (
+                        s
+                        for s in category_skills
+                        if s.get("name") == skill_id or s.get("skill_id") == skill_id
+                    ),
+                    None,
+                )
+                if skill:
+                    self._install_skill_from_dict(skill)
+                    self.console.print(f"[green]✓ Installed {skill_id}[/green]")
+
+            # Uninstall deselected
+            to_uninstall = current_in_cat - selected_set
+            for skill_id in to_uninstall:
+                # Find the skill to get deployment_name
+                skill = next(
+                    (
+                        s
+                        for s in category_skills
+                        if s.get("name") == skill_id or s.get("skill_id") == skill_id
+                    ),
+                    None,
+                )
+                if skill:
+                    deploy_name = skill.get("deployment_name", skill_id)
+                    # Use the name that's actually in deployed set
+                    name_to_uninstall = (
+                        deploy_name if deploy_name in deployed else skill_id
+                    )
+                    self._uninstall_skill_by_name(name_to_uninstall)
+                    self.console.print(f"[yellow]✗ Uninstalled {skill_id}[/yellow]")
+
+            # Update deployed set for next iteration
+            deployed = self._get_deployed_skill_ids()
+
+            # Show completion message
+            if to_install or to_uninstall:
+                Prompt.ask("\nPress Enter to continue")
+
+    def _get_all_skills_from_git(self) -> list:
+        """Get all skills from Git-based skill manager.
+
+        Returns:
+            List of skill dicts with full metadata from GitSkillSourceManager.
+        """
+        from ...config.skill_sources import SkillSourceConfiguration
+        from ...services.skills.git_skill_source_manager import GitSkillSourceManager
+
+        try:
+            config = SkillSourceConfiguration()
+            manager = GitSkillSourceManager(config)
+            return manager.get_all_skills()
+        except Exception as e:
+            self.console.print(
+                f"[yellow]Warning: Could not load Git skills: {e}[/yellow]"
+            )
+            return []
+
+    def _display_skills_table_grouped(self) -> None:
+        """Display skills in a table grouped by category, like agents."""
+        from rich import box
+        from rich.table import Table
+
+        # Get all skills from Git manager
+        all_skills = self._get_all_skills_from_git()
+        deployed_ids = self._get_deployed_skill_ids()
+
+        if not all_skills:
+            self.console.print(
+                "[yellow]No skills available. Try syncing skills first.[/yellow]"
+            )
+            return
+
+        # Group skills by category/toolchain
+        grouped = {}
+        for skill in all_skills:
+            # Try to get category from tags or use toolchain
+            category = None
+            tags = skill.get("tags", [])
+
+            # Look for category tag
+            for tag in tags:
+                if tag in [
+                    "universal",
+                    "python",
+                    "typescript",
+                    "javascript",
+                    "go",
+                    "rust",
+                ]:
+                    category = tag
+                    break
+
+            # Fallback to toolchain or universal
+            if not category:
+                category = skill.get("toolchain", "universal")
+
+            if category not in grouped:
+                grouped[category] = []
+            grouped[category].append(skill)
+
+        # Sort categories: universal first, then alphabetically
+        categories = sorted(grouped.keys(), key=lambda x: (x != "universal", x))
+
+        # Track global skill number across all categories
+        skill_counter = 0
+
+        for category in categories:
+            category_skills = grouped[category]
+
+            # Category header with icon
+            icons = {
+                "universal": "🌐",
+                "python": "🐍",
+                "typescript": "📘",
+                "javascript": "📒",
+                "go": "🔷",
+                "rust": "⚙️",
+            }
+            icon = icons.get(category, "📦")
+            self.console.print(
+                f"\n{icon} [bold cyan]{category.title()}[/bold cyan] ({len(category_skills)} skills)"
+            )
+
+            # Create table for this category
+            table = Table(show_header=True, header_style="bold", box=box.SIMPLE)
+            table.add_column("#", style="dim", width=4)
+            table.add_column("Skill ID", style="cyan", width=35)
+            table.add_column("Description", style="white", width=45)
+            table.add_column("Status", style="green", width=12)
+
+            for skill in sorted(category_skills, key=lambda x: x.get("name", "")):
+                skill_counter += 1
+                skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                # Use deployment_name for matching if available
+                deploy_name = skill.get("deployment_name", skill_id)
+                description = skill.get("description", "")[:45]
+
+                # Check if installed - handle both deployment_name and skill_id
+                is_installed = deploy_name in deployed_ids or skill_id in deployed_ids
+                status = "[green]✓ Installed[/green]" if is_installed else "Available"
+
+                table.add_row(str(skill_counter), skill_id, description, status)
+
+            self.console.print(table)
+
+        # Summary
+        total = len(all_skills)
+        installed = sum(
+            1
+            for s in all_skills
+            if s.get("deployment_name", s.get("name", "")) in deployed_ids
+            or s.get("name", "") in deployed_ids
+        )
+        self.console.print(
+            f"\n[dim]Showing {total} skills ({installed} installed)[/dim]"
+        )
+
+    def _get_deployed_skill_ids(self) -> set:
+        """Get set of deployed skill IDs from .claude/skills/ directory.
+
+        Returns:
+            Set of skill directory names and common variations for matching.
+        """
+        from pathlib import Path
+
+        skills_dir = Path.cwd() / ".claude" / "skills"
+        if not skills_dir.exists():
+            return set()
+
+        # Each deployed skill is a directory in .claude/skills/
+        deployed_ids = set()
+        for skill_dir in skills_dir.iterdir():
+            if skill_dir.is_dir() and not skill_dir.name.startswith("."):
+                # Add both the directory name and common variations
+                deployed_ids.add(skill_dir.name)
+                # Also add without prefix for matching (e.g., universal-testing -> testing)
+                if skill_dir.name.startswith("universal-"):
+                    deployed_ids.add(skill_dir.name.replace("universal-", "", 1))
+
+        return deployed_ids
+
+    def _install_skill(self, skill) -> None:
+        """Install a skill to .claude/skills/ directory."""
+        import shutil
+        from pathlib import Path
+
+        # Target directory
+        target_dir = Path.cwd() / ".claude" / "skills" / skill.skill_id
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy skill file(s)
+        if skill.path.is_file():
+            # Single file skill - copy to skill.md in target directory
+            shutil.copy2(skill.path, target_dir / "skill.md")
+        elif skill.path.is_dir():
+            # Directory-based skill - copy all contents
+            for item in skill.path.iterdir():
+                if item.is_file():
+                    shutil.copy2(item, target_dir / item.name)
+                elif item.is_dir():
+                    shutil.copytree(item, target_dir / item.name, dirs_exist_ok=True)
+
+    def _uninstall_skill(self, skill) -> None:
+        """Uninstall a skill from .claude/skills/ directory."""
+        import shutil
+        from pathlib import Path
+
+        target_dir = Path.cwd() / ".claude" / "skills" / skill.skill_id
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+
+    def _install_skill_from_dict(self, skill_dict: dict) -> None:
+        """Install a skill from Git skill dict to .claude/skills/ directory.
+
+        Args:
+            skill_dict: Skill metadata dict from GitSkillSourceManager.get_all_skills()
+        """
+        from pathlib import Path
+
+        skill_id = skill_dict.get("name", skill_dict.get("skill_id", "unknown"))
+        content = skill_dict.get("content", "")
+
+        if not content:
+            self.console.print(
+                f"[yellow]Warning: Skill '{skill_id}' has no content[/yellow]"
+            )
+            return
+
+        # Target directory using deployment_name if available
+        deploy_name = skill_dict.get("deployment_name", skill_id)
+        target_dir = Path.cwd() / ".claude" / "skills" / deploy_name
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Write skill content to skill.md
+        skill_file = target_dir / "skill.md"
+        skill_file.write_text(content, encoding="utf-8")
+
+    def _uninstall_skill_by_name(self, skill_name: str) -> None:
+        """Uninstall a skill by name from .claude/skills/ directory.
+
+        Args:
+            skill_name: Name of skill directory to remove
+        """
+        import shutil
+        from pathlib import Path
+
+        target_dir = Path.cwd() / ".claude" / "skills" / skill_name
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+
     def _display_behavior_files(self) -> None:
         """Display current behavior files."""
         self.behavior_manager.display_behavior_files()
@@ -1437,18 +1993,20 @@ class ConfigureCommand(BaseCommand):
 
                 # Add inline control: Select/Deselect all from this collection
                 if all_selected:
+                    deselect_value = f"__DESELECT_ALL_{collection_id}__"
                     choices.append(
                         Choice(
-                            f"  [Deselect all from {collection_id}]",
-                            value=f"__DESELECT_ALL_{collection_id}__",
+                            f"  [Deselect all from {collection_id}]",  # nosec B608
+                            value=deselect_value,
                             checked=False,
                         )
                     )
                 else:
+                    select_value = f"__SELECT_ALL_{collection_id}__"
                     choices.append(
                         Choice(
-                            f"  [Select all from {collection_id}]",
-                            value=f"__SELECT_ALL_{collection_id}__",
+                            f"  [Select all from {collection_id}]",  # nosec B608
+                            value=select_value,
                             checked=False,
                         )
                     )
@@ -1518,18 +2076,32 @@ class ConfigureCommand(BaseCommand):
                         )
                         display_name = self._format_display_name(raw_display_name)
 
-                        # Check if agent is deployed (exists in .claude/agents/)
+                        # Check if agent is required (cannot be unchecked)
+                        required_agents = set(self.unified_config.agents.required)
+                        is_required = (
+                            agent_leaf_name in required_agents
+                            or agent_id in required_agents
+                        )
 
-                        # Format choice text (no asterisk needed)
-                        choice_text = f"    {display_name}"
+                        # Format choice text with [Required] indicator
+                        if is_required:
+                            choice_text = f"    {display_name} [Required]"
+                        else:
+                            choice_text = f"    {display_name}"
 
-                        is_selected = agent_id in current_selection
+                        # Required agents are always selected
+                        is_selected = is_required or agent_id in current_selection
+
+                        # Add to current selection if required
+                        if is_required:
+                            current_selection.add(agent_id)
 
                         choices.append(
                             Choice(
                                 title=choice_text,
                                 value=agent_id,  # Use agent_id for value
                                 checked=is_selected,
+                                disabled=is_required,  # Disable checkbox for required agents
                             )
                         )
 
@@ -1538,6 +2110,7 @@ class ConfigureCommand(BaseCommand):
             self.console.print(
                 "[dim][ ] Unchecked = Available (check to install)[/dim]"
             )
+            self.console.print("[dim][Required] = Core agents (always installed)[/dim]")
             self.console.print(
                 "[dim]Use arrow keys to navigate, space to toggle, Enter to apply[/dim]\n"
             )
@@ -1624,12 +2197,37 @@ class ConfigureCommand(BaseCommand):
 
             # No controls selected - use the individual selections as final
             final_selection = set(selected_values)
+
+            # Ensure required agents are always in the final selection
+            required_agents = set(self.unified_config.agents.required)
+            for agent in agents:
+                agent_id = getattr(agent, "agent_id", agent.name)
+                agent_leaf_name = agent_id.split("/")[-1]
+                if agent_leaf_name in required_agents or agent_id in required_agents:
+                    final_selection.add(agent_id)
+
             break
 
         # Determine changes
         to_deploy = final_selection - deployed_full_paths
         to_remove = deployed_full_paths - final_selection
 
+        # Prevent removal of required agents
+        required_agents = set(self.unified_config.agents.required)
+        to_remove_filtered = set()
+        for agent_id in to_remove:
+            agent_leaf_name = agent_id.split("/")[-1]
+            if (
+                agent_leaf_name not in required_agents
+                and agent_id not in required_agents
+            ):
+                to_remove_filtered.add(agent_id)
+            else:
+                self.console.print(
+                    f"[yellow]⚠ Cannot remove required agent: {agent_id}[/yellow]"
+                )
+        to_remove = to_remove_filtered
+
         if not to_deploy and not to_remove:
             self.console.print("[yellow]No changes needed[/yellow]")
             Prompt.ask("\nPress Enter to continue")
@@ -2329,7 +2927,8 @@ class ConfigureCommand(BaseCommand):
                 f"  Detection Quality: [{'green' if summary.get('detection_quality') == 'high' else 'yellow'}]{summary.get('detection_quality', 'unknown')}[/]"
             )
             self.console.print()
-        except Exception:
+        except Exception:  # nosec B110 - Suppress broad except for failed safety check
+            # Silent failure on safety check - non-critical feature
             pass
 
         # Build mapping: agent_id -> AgentConfig