crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/intelligence/agent_registry.py

@@ -202,7 +202,7 @@ class AgentRegistry:
 
     def _build_agent_data(self, lines: list[str], yaml_end: int) -> dict[str, t.Any]:
         yaml_lines = lines[1:yaml_end]
-        agent_data = {}
+        agent_data: dict[str, t.Any] = {}
 
         for line in yaml_lines:
             if ": " in line:
@@ -213,36 +213,46 @@ class AgentRegistry:
         return agent_data
 
     def _infer_capabilities_from_agent(self, agent: SubAgent) -> set[AgentCapability]:
-        capabilities = set()
-
+        """Infer agent capabilities from class name using keyword mapping."""
         class_name = agent.__class__.__name__.lower()
+        capability_mapping = self._get_agent_capability_mapping()
 
-        if "architect" in class_name:
-            capabilities.update(
-                {AgentCapability.ARCHITECTURE, AgentCapability.CODE_ANALYSIS}
-            )
-        if "refactor" in class_name:
-            capabilities.add(AgentCapability.REFACTORING)
-        if "test" in class_name:
-            capabilities.add(AgentCapability.TESTING)
-        if "security" in class_name:
-            capabilities.add(AgentCapability.SECURITY)
-        if "performance" in class_name:
-            capabilities.add(AgentCapability.PERFORMANCE)
-        if "documentation" in class_name or "doc" in class_name:
-            capabilities.add(AgentCapability.DOCUMENTATION)
-        if "format" in class_name:
-            capabilities.add(AgentCapability.FORMATTING)
-        if "import" in class_name:
-            capabilities.add(AgentCapability.CODE_ANALYSIS)
-        if "dry" in class_name:
-            capabilities.add(AgentCapability.REFACTORING)
+        capabilities = set()
+        for keywords, caps in capability_mapping:
+            if self._class_name_matches_keywords(class_name, keywords):
+                capabilities.update(caps)
 
+        # Fallback to default capability if none found
         if not capabilities:
             capabilities.add(AgentCapability.CODE_ANALYSIS)
 
         return capabilities
 
+    def _get_agent_capability_mapping(
+        self,
+    ) -> list[tuple[list[str], set[AgentCapability]]]:
+        """Get mapping of keywords to agent capabilities."""
+        return [
+            (
+                ["architect"],
+                {AgentCapability.ARCHITECTURE, AgentCapability.CODE_ANALYSIS},
+            ),
+            (["refactor"], {AgentCapability.REFACTORING}),
+            (["test"], {AgentCapability.TESTING}),
+            (["security"], {AgentCapability.SECURITY}),
+            (["performance"], {AgentCapability.PERFORMANCE}),
+            (["documentation", "doc"], {AgentCapability.DOCUMENTATION}),
+            (["format"], {AgentCapability.FORMATTING}),
+            (["import"], {AgentCapability.CODE_ANALYSIS}),
+            (["dry"], {AgentCapability.REFACTORING}),
+        ]
+
+    def _class_name_matches_keywords(
+        self, class_name: str, keywords: list[str]
+    ) -> bool:
+        """Check if class name contains any of the specified keywords."""
+        return any(keyword in class_name for keyword in keywords)
+
     def _infer_capabilities_from_user_agent(
         self, agent_data: dict[str, t.Any]
     ) -> set[AgentCapability]:
@@ -334,7 +344,7 @@ class AgentRegistry:
         return self._agents.get(name)
 
     def list_all_agents(self) -> list[RegisteredAgent]:
-        agents = list(self._agents.values())
+        agents = list[t.Any](self._agents.values())
         agents.sort(key=lambda a: a.metadata.priority, reverse=True)
         return agents
 

crackerjack/intelligence/agent_selector.py

@@ -143,9 +143,7 @@ class AgentSelector:
 
         capabilities = set()
         for pattern, caps in self._task_patterns.items():
-            if re.search(
-                pattern, text, re.IGNORECASE
-            ):  # REGEX OK: dynamic pattern matching from config
+            if re.search(pattern, text, re.IGNORECASE):
                 capabilities.update(caps)
 
         return capabilities
@@ -182,7 +180,7 @@ class AgentSelector:
             TaskContext.GENERAL: [AgentCapability.CODE_ANALYSIS],
         }
 
-        return set(context_map.get(task.context, []))
+        return set[t.Any](context_map.get(task.context, []))
 
     def _analyze_file_patterns(self, task: TaskDescription) -> set[AgentCapability]:
         if not task.file_patterns:
@@ -291,8 +289,8 @@ class AgentSelector:
         if not agent.metadata.description:
             return 0.0
 
-        desc_words = set(agent.metadata.description.lower().split())
-        task_words = set(task_text.split())
+        desc_words = set[t.Any](agent.metadata.description.lower().split())
+        task_words = set[t.Any](task_text.split())
         common_words = desc_words & task_words
 
         if common_words:
@@ -355,7 +353,7 @@ class AgentSelector:
         parts.append(source_desc.get(agent.metadata.source.value, "Unknown source"))
 
         if agent.metadata.capabilities:
-            top_caps = list(agent.metadata.capabilities)[:2]
+            top_caps = list[t.Any](agent.metadata.capabilities)[:2]
             cap_names = [cap.value.replace("_", " ") for cap in top_caps]
             parts.append(f"Strengths: {', '.join(cap_names)}")
 

crackerjack/interactive.py

@@ -37,12 +37,23 @@ class WorkflowOptions:
     @classmethod
     def from_args(cls, args: t.Any) -> "WorkflowOptions":
         return cls(
-            clean=getattr(args, "clean", False),
-            test=getattr(args, "test", False),
-            publish=getattr(args, "publish", None),
-            bump=getattr(args, "bump", None),
-            commit=getattr(args, "commit", False),
-            create_pr=getattr(args, "create_pr", False),
+            cleaning=CleaningConfig(
+                clean=getattr(args, "clean", False),
+            ),
+            testing=TestConfig(
+                test=getattr(args, "test", False),
+            ),
+            publishing=PublishConfig(
+                publish=getattr(args, "publish", None),
+                bump=getattr(args, "bump", None),
+            ),
+            git=GitConfig(
+                commit=getattr(args, "commit", False),
+                create_pr=getattr(args, "create_pr", False),
+            ),
+            ai=AIConfig(
+                ai_agent=getattr(args, "ai_agent", False),
+            ),
             interactive=getattr(args, "interactive", True),
             dry_run=getattr(args, "dry_run", False),
         )

crackerjack/managers/async_hook_manager.py

@@ -28,7 +28,6 @@ class AsyncHookManager:
         self._config_path: Path | None = None
 
     def set_config_path(self, config_path: Path) -> None:
-        """Set the path to the pre-commit configuration file."""
         self._config_path = config_path
 
     async def run_fast_hooks_async(self) -> list[HookResult]:

crackerjack/managers/hook_manager.py

@@ -6,6 +6,7 @@ from rich.console import Console
 
 from crackerjack.config.hooks import HookConfigLoader
 from crackerjack.executors.hook_executor import HookExecutor
+from crackerjack.executors.lsp_aware_hook_executor import LSPAwareHookExecutor
 from crackerjack.models.task import HookResult
 
 
@@ -16,12 +17,25 @@ class HookManagerImpl:
         pkg_path: Path,
         verbose: bool = False,
         quiet: bool = False,
+        enable_lsp_optimization: bool = False,
+        enable_tool_proxy: bool = True,
     ) -> None:
         self.console = console
         self.pkg_path = pkg_path
-        self.executor = HookExecutor(console, pkg_path, verbose, quiet)
+        self.executor: HookExecutor
+
+        # Use LSP-aware executor if optimization is enabled
+        if enable_lsp_optimization:
+            self.executor = LSPAwareHookExecutor(
+                console, pkg_path, verbose, quiet, use_tool_proxy=enable_tool_proxy
+            )
+        else:
+            self.executor = HookExecutor(console, pkg_path, verbose, quiet)
+
         self.config_loader = HookConfigLoader()
         self._config_path: Path | None = None
+        self.lsp_optimization_enabled = enable_lsp_optimization
+        self.tool_proxy_enabled = enable_tool_proxy
 
     def set_config_path(self, config_path: Path) -> None:
         self._config_path = config_path
@@ -49,6 +63,70 @@ class HookManagerImpl:
         comprehensive_results = self.run_comprehensive_hooks()
         return fast_results + comprehensive_results
 
+    def get_execution_info(self) -> dict[str, t.Any]:
+        """Get information about current execution mode and capabilities."""
+        info = {
+            "lsp_optimization_enabled": self.lsp_optimization_enabled,
+            "tool_proxy_enabled": self.tool_proxy_enabled,
+            "executor_type": type(self.executor).__name__,
+        }
+
+        # Get LSP-specific info if available
+        if hasattr(self.executor, "get_execution_mode_summary"):
+            info.update(self.executor.get_execution_mode_summary())
+
+        return info
+
+    def configure_lsp_optimization(self, enable: bool) -> None:
+        """Enable or disable LSP optimization by switching executors."""
+        if enable == self.lsp_optimization_enabled:
+            return  # Already in the correct state
+
+        # Switch executor based on the enable flag
+        if enable:
+            self.executor = LSPAwareHookExecutor(
+                self.console,
+                self.pkg_path,
+                verbose=getattr(self.executor, "verbose", False),
+                quiet=getattr(self.executor, "quiet", True),
+                use_tool_proxy=self.tool_proxy_enabled,
+            )
+        else:
+            self.executor = HookExecutor(
+                self.console,
+                self.pkg_path,
+                verbose=getattr(self.executor, "verbose", False),
+                quiet=getattr(self.executor, "quiet", True),
+            )
+
+        self.lsp_optimization_enabled = enable
+
+        # Restore config path if it was set[t.Any]
+        if self._config_path:
+            # Config path is set[t.Any] at the manager level, not executor level
+            pass
+
+    def configure_tool_proxy(self, enable: bool) -> None:
+        """Enable or disable tool proxy resilience."""
+        if enable == self.tool_proxy_enabled:
+            return  # Already in the correct state
+
+        self.tool_proxy_enabled = enable
+
+        # If using LSP-aware executor, recreate it with new tool proxy setting
+        if isinstance(self.executor, LSPAwareHookExecutor):
+            self.executor = LSPAwareHookExecutor(
+                self.console,
+                self.pkg_path,
+                verbose=getattr(self.executor, "verbose", False),
+                quiet=getattr(self.executor, "quiet", True),
+                use_tool_proxy=enable,
+            )
+
+            # Restore config path if it was set[t.Any]
+            if self._config_path:
+                pass  # Config path handled at manager level
+
     def validate_hooks_config(self) -> bool:
         try:
             result = subprocess.run(

crackerjack/managers/publish_manager.py

@@ -5,17 +5,34 @@ from pathlib import Path
 
 from rich.console import Console
 
-from crackerjack.services.filesystem import FileSystemService
-from crackerjack.services.security import SecurityService
+from crackerjack.models.protocols import FileSystemInterface, SecurityServiceProtocol
 
 
 class PublishManagerImpl:
-    def __init__(self, console: Console, pkg_path: Path, dry_run: bool = False) -> None:
+    def __init__(
+        self,
+        console: Console,
+        pkg_path: Path,
+        dry_run: bool = False,
+        filesystem: FileSystemInterface | None = None,
+        security: SecurityServiceProtocol | None = None,
+    ) -> None:
         self.console = console
         self.pkg_path = pkg_path
         self.dry_run = dry_run
-        self.filesystem = FileSystemService()
-        self.security = SecurityService()
+
+        if filesystem is None:
+            from crackerjack.services.filesystem import FileSystemService
+
+            filesystem = FileSystemService()
+
+        if security is None:
+            from crackerjack.services.security import SecurityService
+
+            security = SecurityService()
+
+        self.filesystem = filesystem
+        self.security = security
 
     def _run_command(
         self,
@@ -50,7 +67,8 @@ class PublishManagerImpl:
 
             content = self.filesystem.read_file(pyproject_path)
             data = loads(content)
-            return data.get("project", {}).get("version")
+            version = data.get("project", {}).get("version")
+            return version if isinstance(version, str) else None
         except Exception as e:
             self.console.print(f"[yellow]⚠️[/ yellow] Error reading version: {e}")
             return None
@@ -117,6 +135,8 @@ class PublishManagerImpl:
                 self.console.print(
                     f"[green]🚀[/ green] Bumped {version_type} version: {current_version} → {new_version}",
                 )
+                # Update changelog after successful version bump
+                self._update_changelog_for_version(current_version, new_version)
             else:
                 msg = "Failed to update version in file"
                 raise ValueError(msg)
@@ -180,7 +200,7 @@ class PublishManagerImpl:
                 [
                     "keyring",
                     "get",
-                    "https://upload.pypi.org/legacy/",
+                    "https: //upload.pypi.org/legacy/",
                     "__token__",
                 ],
             )
@@ -211,7 +231,7 @@ class PublishManagerImpl:
             " 1. Set environment variable: export UV_PUBLISH_TOKEN=<your-pypi-token>",
         )
         self.console.print(
-            " 2. Use keyring: keyring set https://upload.pypi.org/legacy/ __token__",
+            " 2. Use keyring: keyring set[t.Any] https: //upload.pypi.org/legacy/ __token__",
         )
         self.console.print(
             " 3. Ensure token starts with 'pypi-' and is properly formatted",
@@ -269,7 +289,7 @@ class PublishManagerImpl:
         if not dist_dir.exists():
             return
 
-        artifacts = list(dist_dir.glob("*"))
+        artifacts = list[t.Any](dist_dir.glob("*"))
         self.console.print(f"[cyan]📦[/ cyan] Build artifacts ({len(artifacts)}): ")
 
         for artifact in artifacts[-5:]:
@@ -278,8 +298,8 @@ class PublishManagerImpl:
 
     def _format_file_size(self, size: int) -> str:
         if size < 1024 * 1024:
-            return f"{size / 1024:.1f}KB"
-        return f"{size / (1024 * 1024):.1f}MB"
+            return f"{size / 1024: .1f}KB"
+        return f"{size / (1024 * 1024): .1f}MB"
 
     def publish_package(self) -> bool:
         if not self._validate_prerequisites():
@@ -330,7 +350,7 @@ class PublishManagerImpl:
         package_name = self._get_package_name()
 
         if package_name and current_version:
-            url = f"https://pypi.org/project/{package_name}/{current_version}/"
+            url = f"https: //pypi.org/project/{package_name}/{current_version}/"
             self.console.print(f"[cyan]🔗[/ cyan] Package URL: {url}")
 
     def _get_package_name(self) -> str | None:
@@ -341,7 +361,8 @@ class PublishManagerImpl:
 
             content = self.filesystem.read_file(pyproject_path)
             data = loads(content)
-            return data.get("project", {}).get("name", "")
+            name = data.get("project", {}).get("name", "")
+            return name if isinstance(name, str) else None
 
         return None
 
@@ -429,3 +450,35 @@ class PublishManagerImpl:
         except Exception as e:
             self.console.print(f"[yellow]⚠️[/ yellow] Error reading package info: {e}")
             return {}
+
+    def _update_changelog_for_version(self, old_version: str, new_version: str) -> None:
+        """Update changelog with entries from git commits since last version."""
+        try:
+            from crackerjack.services.changelog_automation import ChangelogGenerator
+            from crackerjack.services.git import GitService
+
+            # Initialize services
+            git_service = GitService(self.console, self.pkg_path)
+            changelog_generator = ChangelogGenerator(self.console, git_service)
+
+            # Look for changelog file
+            changelog_path = self.pkg_path / "CHANGELOG.md"
+
+            # Generate changelog entries since last version
+            success = changelog_generator.generate_changelog_from_commits(
+                changelog_path=changelog_path,
+                version=new_version,
+                since_version=f"v{old_version}",  # Assumes git tags are prefixed with 'v'
+            )
+
+            if success:
+                self.console.print(
+                    f"[green]📝[/green] Updated changelog for version {new_version}"
+                )
+            else:
+                self.console.print(
+                    "[yellow]⚠️[/yellow] Changelog update encountered issues"
+                )
+
+        except Exception as e:
+            self.console.print(f"[yellow]⚠️[/yellow] Failed to update changelog: {e}")

crackerjack/managers/test_command_builder.py

@@ -8,7 +8,7 @@ class TestCommandBuilder:
         self.pkg_path = pkg_path
 
     def build_command(self, options: OptionsProtocol) -> list[str]:
-        cmd = ["python", "-m", "pytest"]
+        cmd = ["uv", "run", "python", "-m", "pytest"]
 
         self._add_coverage_options(cmd, options)
         self._add_worker_options(cmd, options)
@@ -23,22 +23,8 @@ class TestCommandBuilder:
         if hasattr(options, "test_workers") and options.test_workers:
             return options.test_workers
 
-        # Temporarily disable multi-worker execution due to pytest-xdist
-        # hanging issues with async tests. See GitHub issue for details.
-        # TODO: Re-enable after fixing async test timeout issues
         return 1
 
-        # Original multi-worker logic (commented out):
-        # import multiprocessing
-        # cpu_count = multiprocessing.cpu_count()
-        # if cpu_count <= 2:
-        #     return 1
-        # elif cpu_count <= 4:
-        #     return 2
-        # elif cpu_count <= 8:
-        #     return 3
-        # return 4
-
     def get_test_timeout(self, options: OptionsProtocol) -> int:
         if hasattr(options, "test_timeout") and options.test_timeout:
             return options.test_timeout
@@ -68,7 +54,7 @@ class TestCommandBuilder:
                 [
                     "--benchmark-only",
                     "--benchmark-sort=mean",
-                    "--benchmark-columns=min,max,mean,stddev",
+                    "--benchmark-columns=min, max, mean, stddev",
                 ]
             )
 
@@ -99,7 +85,7 @@ class TestCommandBuilder:
         cmd.append(str(self.pkg_path))
 
     def build_specific_test_command(self, test_pattern: str) -> list[str]:
-        cmd = ["python", "-m", "pytest", "-v"]
+        cmd = ["uv", "run", "python", "-m", "pytest", "-v"]
 
         cmd.extend(
             [
@@ -116,6 +102,8 @@ class TestCommandBuilder:
 
     def build_validation_command(self) -> list[str]:
         return [
+            "uv",
+            "run",
             "python",
             "-m",
             "pytest",

crackerjack/managers/test_executor.py

@@ -189,9 +189,7 @@ class TestExecutor:
 
     def _handle_collection_completion(self, line: str, progress: TestProgress) -> bool:
         if "collected" in line and ("item" in line or "test" in line):
-            match = re.search(
-                r"(\d +) (?: item | test)", line
-            )  # REGEX OK: parsing pytest output format
+            match = re.search(r"(\d +) (?: item | test)", line)
             if match:
                 progress.update(
                     total_tests=int(match.group(1)),

crackerjack/managers/test_manager.py

@@ -5,25 +5,44 @@ from pathlib import Path
 
 from rich.console import Console
 
-from crackerjack.models.protocols import OptionsProtocol
-from crackerjack.services.coverage_ratchet import CoverageRatchetService
+from crackerjack.models.protocols import CoverageRatchetProtocol, OptionsProtocol
 
 from .test_command_builder import TestCommandBuilder
 from .test_executor import TestExecutor
 
 
 class TestManager:
-    def __init__(self, console: Console, pkg_path: Path) -> None:
+    def __init__(
+        self,
+        console: Console,
+        pkg_path: Path,
+        coverage_ratchet: CoverageRatchetProtocol | None = None,
+    ) -> None:
         self.console = console
         self.pkg_path = pkg_path
 
         self.executor = TestExecutor(console, pkg_path)
         self.command_builder = TestCommandBuilder(pkg_path)
-        self.coverage_ratchet = CoverageRatchetService(pkg_path, console)
+
+        if coverage_ratchet is None:
+            from crackerjack.services.coverage_ratchet import CoverageRatchetService
+
+            coverage_ratchet_obj = CoverageRatchetService(pkg_path, console)
+            self.coverage_ratchet: CoverageRatchetProtocol | None = t.cast(
+                CoverageRatchetProtocol, coverage_ratchet_obj
+            )
+        else:
+            self.coverage_ratchet = coverage_ratchet
 
         self._last_test_failures: list[str] = []
         self._progress_callback: t.Callable[[dict[str, t.Any]], None] | None = None
         self.coverage_ratchet_enabled = True
+        self.use_lsp_diagnostics = True
+
+        # Initialize coverage badge service
+        from crackerjack.services.coverage_badge_service import CoverageBadgeService
+
+        self._coverage_badge_service = CoverageBadgeService(console, pkg_path)
 
     def set_progress_callback(
         self,
@@ -145,11 +164,11 @@ class TestManager:
             test_path = self.pkg_path / test_dir
             if test_path.exists() and test_path.is_dir():
                 for test_file_pattern in test_files:
-                    if list(test_path.glob(f"**/{test_file_pattern}")):
+                    if list[t.Any](test_path.glob(f"**/{test_file_pattern}")):
                         return True
 
         for test_file_pattern in test_files:
-            if list(self.pkg_path.glob(test_file_pattern)):
+            if list[t.Any](self.pkg_path.glob(test_file_pattern)):
                 return True
 
         return False
@@ -201,8 +220,44 @@ class TestManager:
             return True
 
         ratchet_result = self.coverage_ratchet.check_and_update_coverage()
+
+        # Update coverage badge if coverage information is available
+        self._update_coverage_badge(ratchet_result)
+
         return self._handle_ratchet_result(ratchet_result)
 
+    def _update_coverage_badge(self, ratchet_result: dict[str, t.Any]) -> None:
+        """Update coverage badge in README.md if coverage changed."""
+        try:
+            # Get current coverage directly from coverage.json to ensure freshest data
+            import json
+
+            current_coverage = None
+            coverage_json_path = self.pkg_path / "coverage.json"
+
+            if coverage_json_path.exists():
+                with coverage_json_path.open() as f:
+                    data = json.load(f)
+                    current_coverage = data.get("totals", {}).get("percent_covered")
+
+            # Fallback to ratchet result if coverage.json not available
+            if current_coverage is None:
+                current_coverage = ratchet_result.get("current_coverage")
+
+            # Final fallback to coverage service
+            if current_coverage is None:
+                coverage_info = self.get_coverage()
+                current_coverage = coverage_info.get("coverage_percent")
+
+            if current_coverage is not None:
+                if self._coverage_badge_service.should_update_badge(current_coverage):
+                    self._coverage_badge_service.update_readme_coverage_badge(
+                        current_coverage
+                    )
+        except Exception as e:
+            # Don't fail the test process if badge update fails
+            self.console.print(f"[yellow]⚠️[/yellow] Badge update failed: {e}")
+
     def _handle_ratchet_result(self, ratchet_result: dict[str, t.Any]) -> bool:
         if ratchet_result.get("success", False):
             if ratchet_result.get("improved", False):
@@ -216,7 +271,7 @@ class TestManager:
                 previous = ratchet_result.get("previous_coverage", 0)
                 self.console.print(
                     f"[red]📉[/ red] Coverage regression: "
-                    f"{current:.2f}% < {previous:.2f}%"
+                    f"{current: .2f}% < {previous: .2f}%"
                 )
             return False
 
@@ -244,5 +299,52 @@ class TestManager:
     def _get_timeout(self, options: OptionsProtocol) -> int:
         return self.command_builder.get_test_timeout(options)
 
+    async def run_pre_test_lsp_diagnostics(self) -> bool:
+        """Run LSP diagnostics before tests to catch type errors early."""
+        if not self.use_lsp_diagnostics:
+            return True
+
+        try:
+            from crackerjack.services.lsp_client import LSPClient
+
+            lsp_client = LSPClient(self.console)
+
+            # Check if LSP server is available
+            if not lsp_client.is_server_running():
+                return True  # No LSP server, skip diagnostics
+
+            # Run type diagnostics on the project
+            diagnostics, summary = lsp_client.check_project_with_feedback(
+                self.pkg_path,
+                show_progress=False,  # Keep quiet for test integration
+            )
+
+            # Check if there are type errors
+            has_errors = any(diags for diags in diagnostics.values())
+
+            if has_errors:
+                self.console.print(
+                    "[yellow]⚠️ LSP detected type errors before running tests[/yellow]"
+                )
+                # Format and show a summary
+                error_count = sum(len(diags) for diags in diagnostics.values())
+                self.console.print(f"[yellow]Found {error_count} type issues[/yellow]")
+
+            return not has_errors  # Return False if there are type errors
+
+        except Exception as e:
+            # If LSP diagnostics fail, don't block tests
+            self.console.print(f"[dim]LSP diagnostics failed: {e}[/dim]")
+            return True
+
+    def configure_lsp_diagnostics(self, enable: bool) -> None:
+        """Enable or disable LSP diagnostics integration."""
+        self.use_lsp_diagnostics = enable
+
+        if enable:
+            self.console.print(
+                "[cyan]🔍 LSP diagnostics enabled for faster test feedback[/cyan]"
+            )
+
 
 TestManagementImpl = TestManager