π OpenHands: AI-Driven Development
fix(backend): organizational skills do not trigger (v1 conversations) (#12037)
Hiep Lef2def8fd7f94
diff --git a/openhands/app_server/app_conversation/app_conversation_service_base.py b/openhands/app_server/app_conversation/app_conversation_service_base.pyindex d5d34bd109..fb1eb0001e 100644--- a/openhands/app_server/app_conversation/app_conversation_service_base.py+++ b/openhands/app_server/app_conversation/app_conversation_service_base.py@@ -22,6 +22,7 @@ from openhands.app_server.app_conversation.app_conversation_service import ()from openhands.app_server.app_conversation.skill_loader import (load_global_skills,+ load_org_skills,load_repo_skills,load_sandbox_skills,merge_skills,@@ -94,13 +95,20 @@ class AppConversationServiceBase(AppConversationService, ABC):except Exception as e:_logger.warning(f'Failed to load user skills: {str(e)}')user_skills = []++ # Load organization-level skills+ org_skills = await load_org_skills(+ remote_workspace, selected_repository, working_dir, self.user_context+ )+repo_skills = await load_repo_skills(remote_workspace, selected_repository, working_dir)# Merge all skills (later lists override earlier ones)+ # Precedence: sandbox < global < user < org < repoall_skills = merge_skills(- [sandbox_skills, global_skills, user_skills, repo_skills]+ [sandbox_skills, global_skills, user_skills, org_skills, repo_skills])_logger.info(diff --git a/openhands/app_server/app_conversation/skill_loader.py b/openhands/app_server/app_conversation/skill_loader.pyindex d8fca7cfc3..d237ff0542 100644--- a/openhands/app_server/app_conversation/skill_loader.py+++ b/openhands/app_server/app_conversation/skill_loader.py@@ -14,6 +14,9 @@ from pathlib import Pathimport openhandsfrom openhands.app_server.sandbox.sandbox_models import SandboxInfo+from openhands.app_server.user.user_context import UserContext+from openhands.integrations.provider import ProviderType+from openhands.integrations.service_types import AuthenticationErrorfrom openhands.sdk.context.skills import Skillfrom openhands.sdk.workspace.remote.async_remote_workspace import AsyncRemoteWorkspace@@ -119,6 +122,96 @@ def _determine_repo_root(working_dir: str, selected_repository: str | None) -> sreturn working_dir+async def _is_gitlab_repository(repo_name: str, user_context: UserContext) -> bool:+ """Check if a repository is hosted on GitLab.++ Args:+ repo_name: Repository name (e.g., "gitlab.com/org/repo" or "org/repo")+ user_context: UserContext to access provider handler++ Returns:+ True if the repository is hosted on GitLab, False otherwise+ """+ try:+ provider_handler = await user_context.get_provider_handler() # type: ignore[attr-defined]+ repository = await provider_handler.verify_repo_provider(repo_name)+ return repository.git_provider == ProviderType.GITLAB+ except Exception:+ # If we can't determine the provider, assume it's not GitLab+ # This is a safe fallback since we'll just use the default .openhands+ return False+++async def _is_azure_devops_repository(+ repo_name: str, user_context: UserContext+) -> bool:+ """Check if a repository is hosted on Azure DevOps.++ Args:+ repo_name: Repository name (e.g., "org/project/repo")+ user_context: UserContext to access provider handler++ Returns:+ True if the repository is hosted on Azure DevOps, False otherwise+ """+ try:+ provider_handler = await user_context.get_provider_handler() # type: ignore[attr-defined]+ repository = await provider_handler.verify_repo_provider(repo_name)+ return repository.git_provider == ProviderType.AZURE_DEVOPS+ except Exception:+ # If we can't determine the provider, assume it's not Azure DevOps+ return False+++async def _determine_org_repo_path(+ selected_repository: str, user_context: UserContext+) -> tuple[str, str]:+ """Determine the organization repository path and organization name.++ Args:+ selected_repository: Repository name (e.g., 'owner/repo' or 'org/project/repo')+ user_context: UserContext to access provider handler++ Returns:+ Tuple of (org_repo_path, org_name) where:+ - org_repo_path: Full path to org-level config repo+ - org_name: Organization name extracted from repository++ Examples:+ - GitHub/Bitbucket: ('owner/.openhands', 'owner')+ - GitLab: ('owner/openhands-config', 'owner')+ - Azure DevOps: ('org/openhands-config/openhands-config', 'org')+ """+ repo_parts = selected_repository.split('/')++ # Determine repository type+ is_azure_devops = await _is_azure_devops_repository(+ selected_repository, user_context+ )+ is_gitlab = await _is_gitlab_repository(selected_repository, user_context)++ # Extract the org/user name+ # Azure DevOps format: org/project/repo (3 parts) - extract org (first part)+ # GitHub/GitLab/Bitbucket format: owner/repo (2 parts) - extract owner (first part)+ if is_azure_devops and len(repo_parts) >= 3:+ org_name = repo_parts[0] # Get org from org/project/repo+ else:+ org_name = repo_parts[-2] # Get owner from owner/repo++ # For GitLab and Azure DevOps, use openhands-config (since .openhands is not a valid repo name)+ # For other providers, use .openhands+ if is_gitlab:+ org_openhands_repo = f'{org_name}/openhands-config'+ elif is_azure_devops:+ # Azure DevOps format: org/project/repo+ # For org-level config, use: org/openhands-config/openhands-config+ org_openhands_repo = f'{org_name}/openhands-config/openhands-config'+ else:+ org_openhands_repo = f'{org_name}/.openhands'++ return org_openhands_repo, org_name++async def _read_file_from_workspace(workspace: AsyncRemoteWorkspace, file_path: str, working_dir: str) -> str | None:@@ -322,6 +415,248 @@ async def load_repo_skills(return []+def _validate_repository_for_org_skills(selected_repository: str) -> bool:+ """Validate that the repository path has sufficient parts for org skills.++ Args:+ selected_repository: Repository name (e.g., 'owner/repo')++ Returns:+ True if repository is valid for org skills loading, False otherwise+ """+ repo_parts = selected_repository.split('/')+ if len(repo_parts) < 2:+ _logger.warning(+ f'Repository path has insufficient parts ({len(repo_parts)} < 2), skipping org-level skills'+ )+ return False+ return True+++async def _get_org_repository_url(+ org_openhands_repo: str, user_context: UserContext+) -> str | None:+ """Get authenticated Git URL for organization repository.++ Args:+ org_openhands_repo: Organization repository path+ user_context: UserContext to access authentication++ Returns:+ Authenticated Git URL if successful, None otherwise+ """+ try:+ remote_url = await user_context.get_authenticated_git_url(org_openhands_repo)+ return remote_url+ except AuthenticationError as e:+ _logger.debug(+ f'org-level skill directory {org_openhands_repo} not found: {str(e)}'+ )+ return None+ except Exception as e:+ _logger.debug(+ f'Failed to get authenticated URL for {org_openhands_repo}: {str(e)}'+ )+ return None+++async def _clone_org_repository(+ workspace: AsyncRemoteWorkspace,+ remote_url: str,+ org_repo_dir: str,+ working_dir: str,+ org_openhands_repo: str,+) -> bool:+ """Clone organization repository to temporary directory.++ Args:+ workspace: AsyncRemoteWorkspace to execute commands+ remote_url: Authenticated Git URL+ org_repo_dir: Temporary directory path for cloning+ working_dir: Working directory for command execution+ org_openhands_repo: Organization repository path (for logging)++ Returns:+ True if clone successful, False otherwise+ """+ _logger.debug(f'Creating temporary directory for org repo: {org_repo_dir}')++ # Clone the repo (shallow clone for efficiency)+ clone_cmd = f'GIT_TERMINAL_PROMPT=0 git clone --depth 1 {remote_url} {org_repo_dir}'+ _logger.info('Executing clone command for org-level repo')++ result = await workspace.execute_command(clone_cmd, working_dir, timeout=120.0)++ if result.exit_code != 0:+ _logger.info(+ f'No org-level skills found at {org_openhands_repo} (exit_code: {result.exit_code})'+ )+ _logger.debug(f'Clone command output: {result.stderr}')+ return False++ _logger.info(f'Successfully cloned org-level skills from {org_openhands_repo}')+ return True+++async def _load_skills_from_org_directories(+ workspace: AsyncRemoteWorkspace, org_repo_dir: str, working_dir: str+) -> tuple[list[Skill], list[Skill]]:+ """Load skills from both skills/ and microagents/ directories in org repo.++ Args:+ workspace: AsyncRemoteWorkspace to execute commands+ org_repo_dir: Path to cloned organization repository+ working_dir: Working directory for command execution++ Returns:+ Tuple of (skills_dir_skills, microagents_dir_skills)+ """+ skills_dir = f'{org_repo_dir}/skills'+ skills_dir_skills = await _find_and_load_skill_md_files(+ workspace, skills_dir, working_dir+ )++ microagents_dir = f'{org_repo_dir}/microagents'+ microagents_dir_skills = await _find_and_load_skill_md_files(+ workspace, microagents_dir, working_dir+ )++ return skills_dir_skills, microagents_dir_skills+++def _merge_org_skills_with_precedence(+ skills_dir_skills: list[Skill], microagents_dir_skills: list[Skill]+) -> list[Skill]:+ """Merge skills from skills/ and microagents/ with proper precedence.++ Precedence: skills/ > microagents/ (skills/ overrides microagents/ for same name)++ Args:+ skills_dir_skills: Skills loaded from skills/ directory+ microagents_dir_skills: Skills loaded from microagents/ directory++ Returns:+ Merged list of skills with proper precedence applied+ """+ skills_by_name = {}+ for skill in microagents_dir_skills + skills_dir_skills:+ # Later sources (skills/) override earlier ones (microagents/)+ if skill.name not in skills_by_name:+ skills_by_name[skill.name] = skill+ else:+ _logger.debug(+ f'Overriding org skill "{skill.name}" from microagents/ with skills/'+ )+ skills_by_name[skill.name] = skill++ return list(skills_by_name.values())+++async def _cleanup_org_repository(+ workspace: AsyncRemoteWorkspace, org_repo_dir: str, working_dir: str+) -> None:+ """Clean up cloned organization repository directory.++ Args:+ workspace: AsyncRemoteWorkspace to execute commands+ org_repo_dir: Path to cloned organization repository+ working_dir: Working directory for command execution+ """+ cleanup_cmd = f'rm -rf {org_repo_dir}'+ await workspace.execute_command(cleanup_cmd, working_dir, timeout=10.0)+++async def load_org_skills(+ workspace: AsyncRemoteWorkspace,+ selected_repository: str | None,+ working_dir: str,+ user_context: UserContext,+) -> list[Skill]:+ """Load organization-level skills from the organization repository.++ For example, if the repository is github.com/acme-co/api, this will check if+ github.com/acme-co/.openhands exists. If it does, it will clone it and load+ the skills from both the ./skills/ and ./microagents/ folders.++ For GitLab repositories, it will use openhands-config instead of .openhands+ since GitLab doesn't support repository names starting with non-alphanumeric+ characters.++ For Azure DevOps repositories, it will use org/openhands-config/openhands-config+ format to match Azure DevOps's three-part repository structure (org/project/repo).++ Args:+ workspace: AsyncRemoteWorkspace to execute commands in the sandbox+ selected_repository: Repository name (e.g., 'owner/repo') or None+ working_dir: Working directory path+ user_context: UserContext to access provider handler and authentication++ Returns:+ List of Skill objects loaded from organization repository.+ Returns empty list if no repository selected or on errors.+ """+ if not selected_repository:+ return []++ try:+ _logger.debug(+ f'Starting org-level skill loading for repository: {selected_repository}'+ )++ # Validate repository path+ if not _validate_repository_for_org_skills(selected_repository):+ return []++ # Determine organization repository path+ org_openhands_repo, org_name = await _determine_org_repo_path(+ selected_repository, user_context+ )++ _logger.info(f'Checking for org-level skills at {org_openhands_repo}')++ # Get authenticated URL for org repository+ remote_url = await _get_org_repository_url(org_openhands_repo, user_context)+ if not remote_url:+ return []++ # Clone the organization repository+ org_repo_dir = f'{working_dir}/_org_openhands_{org_name}'+ clone_success = await _clone_org_repository(+ workspace, remote_url, org_repo_dir, working_dir, org_openhands_repo+ )+ if not clone_success:+ return []++ # Load skills from both skills/ and microagents/ directories+ (+ skills_dir_skills,+ microagents_dir_skills,+ ) = await _load_skills_from_org_directories(+ workspace, org_repo_dir, working_dir+ )++ # Merge skills with proper precedence+ loaded_skills = _merge_org_skills_with_precedence(+ skills_dir_skills, microagents_dir_skills+ )++ _logger.info(+ f'Loaded {len(loaded_skills)} skills from org-level repository {org_openhands_repo}: {[s.name for s in loaded_skills]}'+ )++ # Clean up the org repo directory+ await _cleanup_org_repository(workspace, org_repo_dir, working_dir)++ return loaded_skills++ except AuthenticationError as e:+ _logger.debug(f'org-level skill directory not found: {str(e)}')+ return []+ except Exception as e:+ _logger.warning(f'Failed to load org-level skills: {str(e)}')+ return []++def merge_skills(skill_lists: list[list[Skill]]) -> list[Skill]:"""Merge multiple skill lists, avoiding duplicates by name.diff --git a/tests/unit/app_server/test_app_conversation_service_base.py b/tests/unit/app_server/test_app_conversation_service_base.pyindex 356c454fcf..01fc63bc5d 100644--- a/tests/unit/app_server/test_app_conversation_service_base.py+++ b/tests/unit/app_server/test_app_conversation_service_base.py@@ -15,6 +15,7 @@ from openhands.app_server.app_conversation.app_conversation_models import AgentTfrom openhands.app_server.app_conversation.app_conversation_service_base import (AppConversationServiceBase,)+from openhands.app_server.sandbox.sandbox_models import SandboxInfofrom openhands.app_server.user.user_context import UserContext@@ -916,3 +917,350 @@ async def test_configure_git_user_settings_special_characters_in_name(mock_worksmock_workspace.execute_command.assert_any_call('git config --global user.name "Test O\'Brien"', '/workspace/project')+++# =============================================================================+# Tests for _load_and_merge_all_skills with org skills+# =============================================================================+++class TestLoadAndMergeAllSkillsWithOrgSkills:+ """Test _load_and_merge_all_skills includes organization skills."""++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'+ )+ async def test_load_and_merge_includes_org_skills(+ self,+ mock_load_repo,+ mock_load_org,+ mock_load_user,+ mock_load_global,+ mock_load_sandbox,+ ):+ """Test that _load_and_merge_all_skills loads and merges org skills."""+ # Arrange+ mock_user_context = Mock(spec=UserContext)+ with patch.object(+ AppConversationServiceBase,+ '__abstractmethods__',+ set(),+ ):+ service = AppConversationServiceBase(+ init_git_in_empty_workspace=True,+ user_context=mock_user_context,+ )++ sandbox = Mock(spec=SandboxInfo)+ sandbox.exposed_urls = []+ remote_workspace = AsyncMock()++ # Create distinct mock skills for each source+ sandbox_skill = Mock()+ sandbox_skill.name = 'sandbox_skill'+ global_skill = Mock()+ global_skill.name = 'global_skill'+ user_skill = Mock()+ user_skill.name = 'user_skill'+ org_skill = Mock()+ org_skill.name = 'org_skill'+ repo_skill = Mock()+ repo_skill.name = 'repo_skill'++ mock_load_sandbox.return_value = [sandbox_skill]+ mock_load_global.return_value = [global_skill]+ mock_load_user.return_value = [user_skill]+ mock_load_org.return_value = [org_skill]+ mock_load_repo.return_value = [repo_skill]++ # Act+ result = await service._load_and_merge_all_skills(+ sandbox, remote_workspace, 'owner/repo', '/workspace'+ )++ # Assert+ assert len(result) == 5+ names = {s.name for s in result}+ assert names == {+ 'sandbox_skill',+ 'global_skill',+ 'user_skill',+ 'org_skill',+ 'repo_skill',+ }+ mock_load_org.assert_called_once_with(+ remote_workspace, 'owner/repo', '/workspace', mock_user_context+ )++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'+ )+ async def test_load_and_merge_org_skills_precedence(+ self,+ mock_load_repo,+ mock_load_org,+ mock_load_user,+ mock_load_global,+ mock_load_sandbox,+ ):+ """Test that org skills have correct precedence (higher than user, lower than repo)."""+ # Arrange+ mock_user_context = Mock(spec=UserContext)+ with patch.object(+ AppConversationServiceBase,+ '__abstractmethods__',+ set(),+ ):+ service = AppConversationServiceBase(+ init_git_in_empty_workspace=True,+ user_context=mock_user_context,+ )++ sandbox = Mock(spec=SandboxInfo)+ sandbox.exposed_urls = []+ remote_workspace = AsyncMock()++ # Create skills with same name but different sources+ user_skill = Mock()+ user_skill.name = 'common_skill'+ user_skill.source = 'user'++ org_skill = Mock()+ org_skill.name = 'common_skill'+ org_skill.source = 'org'++ repo_skill = Mock()+ repo_skill.name = 'common_skill'+ repo_skill.source = 'repo'++ mock_load_sandbox.return_value = []+ mock_load_global.return_value = []+ mock_load_user.return_value = [user_skill]+ mock_load_org.return_value = [org_skill]+ mock_load_repo.return_value = [repo_skill]++ # Act+ result = await service._load_and_merge_all_skills(+ sandbox, remote_workspace, 'owner/repo', '/workspace'+ )++ # Assert+ # Should have only one skill with repo source (highest precedence)+ assert len(result) == 1+ assert result[0].source == 'repo'++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'+ )+ async def test_load_and_merge_org_skills_override_user_skills(+ self,+ mock_load_repo,+ mock_load_org,+ mock_load_user,+ mock_load_global,+ mock_load_sandbox,+ ):+ """Test that org skills override user skills for same name."""+ # Arrange+ mock_user_context = Mock(spec=UserContext)+ with patch.object(+ AppConversationServiceBase,+ '__abstractmethods__',+ set(),+ ):+ service = AppConversationServiceBase(+ init_git_in_empty_workspace=True,+ user_context=mock_user_context,+ )++ sandbox = Mock(spec=SandboxInfo)+ sandbox.exposed_urls = []+ remote_workspace = AsyncMock()++ # Create skills with same name+ user_skill = Mock()+ user_skill.name = 'shared_skill'+ user_skill.priority = 'low'++ org_skill = Mock()+ org_skill.name = 'shared_skill'+ org_skill.priority = 'high'++ mock_load_sandbox.return_value = []+ mock_load_global.return_value = []+ mock_load_user.return_value = [user_skill]+ mock_load_org.return_value = [org_skill]+ mock_load_repo.return_value = []++ # Act+ result = await service._load_and_merge_all_skills(+ sandbox, remote_workspace, 'owner/repo', '/workspace'+ )++ # Assert+ assert len(result) == 1+ assert result[0].priority == 'high' # Org skill should win++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'+ )+ async def test_load_and_merge_handles_org_skills_failure(+ self,+ mock_load_repo,+ mock_load_org,+ mock_load_user,+ mock_load_global,+ mock_load_sandbox,+ ):+ """Test that failure to load org skills doesn't break the overall process."""+ # Arrange+ mock_user_context = Mock(spec=UserContext)+ with patch.object(+ AppConversationServiceBase,+ '__abstractmethods__',+ set(),+ ):+ service = AppConversationServiceBase(+ init_git_in_empty_workspace=True,+ user_context=mock_user_context,+ )++ sandbox = Mock(spec=SandboxInfo)+ sandbox.exposed_urls = []+ remote_workspace = AsyncMock()++ global_skill = Mock()+ global_skill.name = 'global_skill'+ repo_skill = Mock()+ repo_skill.name = 'repo_skill'++ mock_load_sandbox.return_value = []+ mock_load_global.return_value = [global_skill]+ mock_load_user.return_value = []+ mock_load_org.return_value = [] # Org skills failed/empty+ mock_load_repo.return_value = [repo_skill]++ # Act+ result = await service._load_and_merge_all_skills(+ sandbox, remote_workspace, 'owner/repo', '/workspace'+ )++ # Assert+ # Should still have skills from other sources+ assert len(result) == 2+ names = {s.name for s in result}+ assert names == {'global_skill', 'repo_skill'}++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'+ )+ async def test_load_and_merge_no_selected_repository(+ self,+ mock_load_repo,+ mock_load_org,+ mock_load_user,+ mock_load_global,+ mock_load_sandbox,+ ):+ """Test skill loading when no repository is selected."""+ # Arrange+ mock_user_context = Mock(spec=UserContext)+ with patch.object(+ AppConversationServiceBase,+ '__abstractmethods__',+ set(),+ ):+ service = AppConversationServiceBase(+ init_git_in_empty_workspace=True,+ user_context=mock_user_context,+ )++ sandbox = Mock(spec=SandboxInfo)+ sandbox.exposed_urls = []+ remote_workspace = AsyncMock()++ global_skill = Mock()+ global_skill.name = 'global_skill'++ mock_load_sandbox.return_value = []+ mock_load_global.return_value = [global_skill]+ mock_load_user.return_value = []+ mock_load_org.return_value = []+ mock_load_repo.return_value = []++ # Act+ result = await service._load_and_merge_all_skills(+ sandbox, remote_workspace, None, '/workspace'+ )++ # Assert+ assert len(result) == 1+ # Org skills should be called even with None repository+ mock_load_org.assert_called_once_with(+ remote_workspace, None, '/workspace', mock_user_context+ )diff --git a/tests/unit/app_server/test_skill_loader.py b/tests/unit/app_server/test_skill_loader.pyindex c9e54ba5a1..e4daadfa14 100644--- a/tests/unit/app_server/test_skill_loader.py+++ b/tests/unit/app_server/test_skill_loader.py@@ -11,15 +11,27 @@ from unittest.mock import AsyncMock, MagicMock, Mock, patchimport pytestfrom openhands.app_server.app_conversation.skill_loader import (+ _cleanup_org_repository,+ _clone_org_repository,+ _determine_org_repo_path,_determine_repo_root,_find_and_load_global_skill_files,_find_and_load_skill_md_files,+ _get_org_repository_url,+ _is_azure_devops_repository,+ _is_gitlab_repository,+ _load_skills_from_org_directories,_load_special_files,+ _merge_org_skills_with_precedence,_read_file_from_workspace,+ _validate_repository_for_org_skills,load_global_skills,+ load_org_skills,load_repo_skills,merge_skills,)+from openhands.integrations.provider import ProviderType+from openhands.integrations.service_types import AuthenticationError# ===== Test Fixtures =====@@ -667,6 +679,669 @@ class TestMergeSkills:assert len(result) == 2+# ===== Tests for Organization Skills Functions =====+++class TestIsGitlabRepository:+ """Test _is_gitlab_repository helper function."""++ @pytest.mark.asyncio+ async def test_is_gitlab_repository_true(self):+ """Test GitLab repository detection returns True."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_provider_handler = AsyncMock()+ mock_repository = Mock()+ mock_repository.git_provider = ProviderType.GITLAB++ mock_user_context.get_provider_handler.return_value = mock_provider_handler+ mock_provider_handler.verify_repo_provider.return_value = mock_repository++ # Act+ result = await _is_gitlab_repository('owner/repo', mock_user_context)++ # Assert+ assert result is True+ mock_provider_handler.verify_repo_provider.assert_called_once_with('owner/repo')++ @pytest.mark.asyncio+ async def test_is_gitlab_repository_false(self):+ """Test non-GitLab repository detection returns False."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_provider_handler = AsyncMock()+ mock_repository = Mock()+ mock_repository.git_provider = ProviderType.GITHUB++ mock_user_context.get_provider_handler.return_value = mock_provider_handler+ mock_provider_handler.verify_repo_provider.return_value = mock_repository++ # Act+ result = await _is_gitlab_repository('owner/repo', mock_user_context)++ # Assert+ assert result is False++ @pytest.mark.asyncio+ async def test_is_gitlab_repository_exception_handling(self):+ """Test exception handling returns False."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_user_context.get_provider_handler.side_effect = Exception('API error')++ # Act+ result = await _is_gitlab_repository('owner/repo', mock_user_context)++ # Assert+ assert result is False+++class TestIsAzureDevOpsRepository:+ """Test _is_azure_devops_repository helper function."""++ @pytest.mark.asyncio+ async def test_is_azure_devops_repository_true(self):+ """Test Azure DevOps repository detection returns True."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_provider_handler = AsyncMock()+ mock_repository = Mock()+ mock_repository.git_provider = ProviderType.AZURE_DEVOPS++ mock_user_context.get_provider_handler.return_value = mock_provider_handler+ mock_provider_handler.verify_repo_provider.return_value = mock_repository++ # Act+ result = await _is_azure_devops_repository(+ 'org/project/repo', mock_user_context+ )++ # Assert+ assert result is True+ mock_provider_handler.verify_repo_provider.assert_called_once_with(+ 'org/project/repo'+ )++ @pytest.mark.asyncio+ async def test_is_azure_devops_repository_false(self):+ """Test non-Azure DevOps repository detection returns False."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_provider_handler = AsyncMock()+ mock_repository = Mock()+ mock_repository.git_provider = ProviderType.GITHUB++ mock_user_context.get_provider_handler.return_value = mock_provider_handler+ mock_provider_handler.verify_repo_provider.return_value = mock_repository++ # Act+ result = await _is_azure_devops_repository('owner/repo', mock_user_context)++ # Assert+ assert result is False++ @pytest.mark.asyncio+ async def test_is_azure_devops_repository_exception_handling(self):+ """Test exception handling returns False."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_user_context.get_provider_handler.side_effect = Exception('Network error')++ # Act+ result = await _is_azure_devops_repository('owner/repo', mock_user_context)++ # Assert+ assert result is False+++class TestDetermineOrgRepoPath:+ """Test _determine_org_repo_path helper function."""++ @pytest.mark.asyncio+ @patch('openhands.app_server.app_conversation.skill_loader._is_gitlab_repository')+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._is_azure_devops_repository'+ )+ async def test_github_repository_path(self, mock_is_azure, mock_is_gitlab):+ """Test org path for GitHub repository."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_is_gitlab.return_value = False+ mock_is_azure.return_value = False++ # Act+ org_repo, org_name = await _determine_org_repo_path(+ 'owner/repo', mock_user_context+ )++ # Assert+ assert org_repo == 'owner/.openhands'+ assert org_name == 'owner'++ @pytest.mark.asyncio+ @patch('openhands.app_server.app_conversation.skill_loader._is_gitlab_repository')+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._is_azure_devops_repository'+ )+ async def test_gitlab_repository_path(self, mock_is_azure, mock_is_gitlab):+ """Test org path for GitLab repository."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_is_gitlab.return_value = True+ mock_is_azure.return_value = False++ # Act+ org_repo, org_name = await _determine_org_repo_path(+ 'owner/repo', mock_user_context+ )++ # Assert+ assert org_repo == 'owner/openhands-config'+ assert org_name == 'owner'++ @pytest.mark.asyncio+ @patch('openhands.app_server.app_conversation.skill_loader._is_gitlab_repository')+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._is_azure_devops_repository'+ )+ async def test_azure_devops_repository_path(self, mock_is_azure, mock_is_gitlab):+ """Test org path for Azure DevOps repository."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_is_gitlab.return_value = False+ mock_is_azure.return_value = True++ # Act+ org_repo, org_name = await _determine_org_repo_path(+ 'org/project/repo', mock_user_context+ )++ # Assert+ assert org_repo == 'org/openhands-config/openhands-config'+ assert org_name == 'org'+++class TestValidateRepositoryForOrgSkills:+ """Test _validate_repository_for_org_skills helper function."""++ def test_valid_repository_two_parts(self):+ """Test validation passes for repository with two parts."""+ # Act+ result = _validate_repository_for_org_skills('owner/repo')++ # Assert+ assert result is True++ def test_valid_repository_three_parts(self):+ """Test validation passes for repository with three parts (Azure DevOps)."""+ # Act+ result = _validate_repository_for_org_skills('org/project/repo')++ # Assert+ assert result is True++ def test_invalid_repository_one_part(self):+ """Test validation fails for repository with only one part."""+ # Act+ result = _validate_repository_for_org_skills('repo')++ # Assert+ assert result is False++ def test_invalid_repository_empty_string(self):+ """Test validation fails for empty string."""+ # Act+ result = _validate_repository_for_org_skills('')++ # Assert+ assert result is False+++class TestGetOrgRepositoryUrl:+ """Test _get_org_repository_url helper function."""++ @pytest.mark.asyncio+ async def test_successful_url_retrieval(self):+ """Test successfully retrieving authenticated URL."""+ # Arrange+ mock_user_context = AsyncMock()+ expected_url = 'https://[email protected]/owner/.openhands.git'+ mock_user_context.get_authenticated_git_url.return_value = expected_url++ # Act+ result = await _get_org_repository_url('owner/.openhands', mock_user_context)++ # Assert+ assert result == expected_url+ mock_user_context.get_authenticated_git_url.assert_called_once_with(+ 'owner/.openhands'+ )++ @pytest.mark.asyncio+ async def test_authentication_error(self):+ """Test handling of authentication error returns None."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_user_context.get_authenticated_git_url.side_effect = AuthenticationError(+ 'Not found'+ )++ # Act+ result = await _get_org_repository_url('owner/.openhands', mock_user_context)++ # Assert+ assert result is None++ @pytest.mark.asyncio+ async def test_general_exception(self):+ """Test handling of general exception returns None."""+ # Arrange+ mock_user_context = AsyncMock()+ mock_user_context.get_authenticated_git_url.side_effect = Exception(+ 'Network error'+ )++ # Act+ result = await _get_org_repository_url('owner/.openhands', mock_user_context)++ # Assert+ assert result is None+++class TestCloneOrgRepository:+ """Test _clone_org_repository helper function."""++ @pytest.mark.asyncio+ async def test_successful_clone(self, mock_async_remote_workspace):+ """Test successful repository clone."""+ # Arrange+ result_obj = Mock()+ result_obj.exit_code = 0+ mock_async_remote_workspace.execute_command.return_value = result_obj++ # Act+ success = await _clone_org_repository(+ mock_async_remote_workspace,+ 'https://github.com/owner/.openhands.git',+ '/workspace/_org_openhands_owner',+ '/workspace',+ 'owner/.openhands',+ )++ # Assert+ assert success is True+ mock_async_remote_workspace.execute_command.assert_called_once()+ call_args = mock_async_remote_workspace.execute_command.call_args+ assert 'git clone' in call_args[0][0]+ assert '--depth 1' in call_args[0][0]++ @pytest.mark.asyncio+ async def test_failed_clone(self, mock_async_remote_workspace):+ """Test failed repository clone."""+ # Arrange+ result_obj = Mock()+ result_obj.exit_code = 1+ result_obj.stderr = 'Repository not found'+ mock_async_remote_workspace.execute_command.return_value = result_obj++ # Act+ success = await _clone_org_repository(+ mock_async_remote_workspace,+ 'https://github.com/owner/.openhands.git',+ '/workspace/_org_openhands_owner',+ '/workspace',+ 'owner/.openhands',+ )++ # Assert+ assert success is False+++class TestLoadSkillsFromOrgDirectories:+ """Test _load_skills_from_org_directories helper function."""++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._find_and_load_skill_md_files'+ )+ async def test_load_from_both_directories(+ self, mock_find_and_load, mock_async_remote_workspace, mock_skills_list+ ):+ """Test loading skills from both skills/ and microagents/ directories."""+ # Arrange+ skills_dir_skills = [mock_skills_list[0]]+ microagents_dir_skills = [mock_skills_list[1], mock_skills_list[2]]+ mock_find_and_load.side_effect = [skills_dir_skills, microagents_dir_skills]++ # Act+ result_skills, result_microagents = await _load_skills_from_org_directories(+ mock_async_remote_workspace, '/workspace/_org_openhands_owner', '/workspace'+ )++ # Assert+ assert result_skills == skills_dir_skills+ assert result_microagents == microagents_dir_skills+ assert mock_find_and_load.call_count == 2++ # Verify correct directories were checked+ first_call = mock_find_and_load.call_args_list[0]+ second_call = mock_find_and_load.call_args_list[1]+ assert '/skills' in first_call[0][1]+ assert '/microagents' in second_call[0][1]++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._find_and_load_skill_md_files'+ )+ async def test_load_with_empty_directories(+ self, mock_find_and_load, mock_async_remote_workspace+ ):+ """Test loading when both directories are empty."""+ # Arrange+ mock_find_and_load.side_effect = [[], []]++ # Act+ result_skills, result_microagents = await _load_skills_from_org_directories(+ mock_async_remote_workspace, '/workspace/_org_openhands_owner', '/workspace'+ )++ # Assert+ assert result_skills == []+ assert result_microagents == []+++class TestMergeOrgSkillsWithPrecedence:+ """Test _merge_org_skills_with_precedence helper function."""++ def test_merge_no_duplicates(self, mock_skills_list):+ """Test merging skills with no name conflicts."""+ # Arrange+ skills_dir_skills = [mock_skills_list[0]]+ microagents_dir_skills = [mock_skills_list[1], mock_skills_list[2]]++ # Act+ result = _merge_org_skills_with_precedence(+ skills_dir_skills, microagents_dir_skills+ )++ # Assert+ assert len(result) == 3+ names = {s.name for s in result}+ assert names == {'skill_0', 'skill_1', 'skill_2'}++ def test_merge_with_duplicate_skills_dir_wins(self):+ """Test skills/ directory takes precedence over microagents/."""+ # Arrange+ skill_from_microagents = Mock()+ skill_from_microagents.name = 'common_skill'+ skill_from_microagents.source = 'microagents'++ skill_from_skills = Mock()+ skill_from_skills.name = 'common_skill'+ skill_from_skills.source = 'skills'++ # Act+ result = _merge_org_skills_with_precedence(+ [skill_from_skills], [skill_from_microagents]+ )++ # Assert+ assert len(result) == 1+ assert result[0].source == 'skills'++ def test_merge_with_empty_lists(self):+ """Test merging with empty skill lists."""+ # Act+ result = _merge_org_skills_with_precedence([], [])++ # Assert+ assert result == []++ def test_merge_with_only_skills_dir(self, mock_skills_list):+ """Test merging with only skills/ directory populated."""+ # Act+ result = _merge_org_skills_with_precedence([mock_skills_list[0]], [])++ # Assert+ assert len(result) == 1+ assert result[0] == mock_skills_list[0]++ def test_merge_with_only_microagents_dir(self, mock_skills_list):+ """Test merging with only microagents/ directory populated."""+ # Act+ result = _merge_org_skills_with_precedence([], [mock_skills_list[0]])++ # Assert+ assert len(result) == 1+ assert result[0] == mock_skills_list[0]+++class TestCleanupOrgRepository:+ """Test _cleanup_org_repository helper function."""++ @pytest.mark.asyncio+ async def test_cleanup_successful(self, mock_async_remote_workspace):+ """Test successful cleanup of org repository directory."""+ # Arrange+ result_obj = Mock()+ result_obj.exit_code = 0+ mock_async_remote_workspace.execute_command.return_value = result_obj++ # Act+ await _cleanup_org_repository(+ mock_async_remote_workspace,+ '/workspace/_org_openhands_owner',+ '/workspace',+ )++ # Assert+ mock_async_remote_workspace.execute_command.assert_called_once()+ call_args = mock_async_remote_workspace.execute_command.call_args+ assert 'rm -rf' in call_args[0][0]+ assert '/workspace/_org_openhands_owner' in call_args[0][0]+++class TestLoadOrgSkills:+ """Test load_org_skills main function."""++ @pytest.mark.asyncio+ async def test_load_org_skills_no_selected_repository(+ self, mock_async_remote_workspace+ ):+ """Test load_org_skills returns empty list when no repository selected."""+ # Arrange+ mock_user_context = AsyncMock()++ # Act+ result = await load_org_skills(+ mock_async_remote_workspace, None, '/workspace', mock_user_context+ )++ # Assert+ assert result == []++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'+ )+ async def test_load_org_skills_invalid_repository(+ self, mock_validate, mock_async_remote_workspace+ ):+ """Test load_org_skills returns empty list for invalid repository."""+ # Arrange+ mock_validate.return_value = False+ mock_user_context = AsyncMock()++ # Act+ result = await load_org_skills(+ mock_async_remote_workspace, 'invalid', '/workspace', mock_user_context+ )++ # Assert+ assert result == []+ mock_validate.assert_called_once_with('invalid')++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._determine_org_repo_path'+ )+ @patch('openhands.app_server.app_conversation.skill_loader._get_org_repository_url')+ async def test_load_org_skills_no_url_available(+ self,+ mock_get_url,+ mock_determine_path,+ mock_validate,+ mock_async_remote_workspace,+ ):+ """Test load_org_skills returns empty list when URL cannot be retrieved."""+ # Arrange+ mock_validate.return_value = True+ mock_determine_path.return_value = ('owner/.openhands', 'owner')+ mock_get_url.return_value = None+ mock_user_context = AsyncMock()++ # Act+ result = await load_org_skills(+ mock_async_remote_workspace,+ 'owner/repo',+ '/workspace',+ mock_user_context,+ )++ # Assert+ assert result == []++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._determine_org_repo_path'+ )+ @patch('openhands.app_server.app_conversation.skill_loader._get_org_repository_url')+ @patch('openhands.app_server.app_conversation.skill_loader._clone_org_repository')+ async def test_load_org_skills_clone_fails(+ self,+ mock_clone,+ mock_get_url,+ mock_determine_path,+ mock_validate,+ mock_async_remote_workspace,+ ):+ """Test load_org_skills returns empty list when clone fails."""+ # Arrange+ mock_validate.return_value = True+ mock_determine_path.return_value = ('owner/.openhands', 'owner')+ mock_get_url.return_value = 'https://github.com/owner/.openhands.git'+ mock_clone.return_value = False+ mock_user_context = AsyncMock()++ # Act+ result = await load_org_skills(+ mock_async_remote_workspace,+ 'owner/repo',+ '/workspace',+ mock_user_context,+ )++ # Assert+ assert result == []++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'+ )+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._determine_org_repo_path'+ )+ @patch('openhands.app_server.app_conversation.skill_loader._get_org_repository_url')+ @patch('openhands.app_server.app_conversation.skill_loader._clone_org_repository')+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._load_skills_from_org_directories'+ )+ @patch('openhands.app_server.app_conversation.skill_loader._cleanup_org_repository')+ async def test_load_org_skills_success(+ self,+ mock_cleanup,+ mock_load_skills,+ mock_clone,+ mock_get_url,+ mock_determine_path,+ mock_validate,+ mock_async_remote_workspace,+ mock_skills_list,+ ):+ """Test successful org skills loading."""+ # Arrange+ mock_validate.return_value = True+ mock_determine_path.return_value = ('owner/.openhands', 'owner')+ mock_get_url.return_value = 'https://github.com/owner/.openhands.git'+ mock_clone.return_value = True+ mock_load_skills.return_value = ([mock_skills_list[0]], [mock_skills_list[1]])+ mock_user_context = AsyncMock()++ # Act+ result = await load_org_skills(+ mock_async_remote_workspace,+ 'owner/repo',+ '/workspace',+ mock_user_context,+ )++ # Assert+ assert len(result) == 2+ mock_cleanup.assert_called_once()++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'+ )+ async def test_load_org_skills_handles_authentication_error(+ self, mock_validate, mock_async_remote_workspace+ ):+ """Test load_org_skills handles AuthenticationError gracefully."""+ # Arrange+ mock_validate.side_effect = AuthenticationError('Auth failed')+ mock_user_context = AsyncMock()++ # Act+ result = await load_org_skills(+ mock_async_remote_workspace,+ 'owner/repo',+ '/workspace',+ mock_user_context,+ )++ # Assert+ assert result == []++ @pytest.mark.asyncio+ @patch(+ 'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'+ )+ async def test_load_org_skills_handles_general_exception(+ self, mock_validate, mock_async_remote_workspace+ ):+ """Test load_org_skills handles general exceptions gracefully."""+ # Arrange+ mock_validate.side_effect = Exception('Unexpected error')+ mock_user_context = AsyncMock()++ # Act+ result = await load_org_skills(+ mock_async_remote_workspace,+ 'owner/repo',+ '/workspace',+ mock_user_context,+ )++ # Assert+ assert result == []++# ===== Integration Tests =====@@ -754,3 +1429,110 @@ class TestSkillLoaderIntegration:# Should have only one skill with repo source (highest precedence)assert len(all_skills) == 1assert all_skills[0].source == 'repo'++ @pytest.mark.asyncio+ @patch('openhands.app_server.app_conversation.skill_loader.load_global_skills')+ @patch('openhands.sdk.context.skills.load_user_skills')+ @patch('openhands.app_server.app_conversation.skill_loader.load_org_skills')+ @patch('openhands.app_server.app_conversation.skill_loader.load_repo_skills')+ async def test_loading_with_org_skills_precedence(+ self,+ mock_load_repo,+ mock_load_org,+ mock_load_user,+ mock_load_global,+ mock_async_remote_workspace,+ ):+ """Test that org skills fit correctly in precedence order."""+ # Arrange+ # Create skills with same name but different sources+ global_skill = Mock()+ global_skill.name = 'shared_skill'+ global_skill.priority = 'low'++ user_skill = Mock()+ user_skill.name = 'shared_skill'+ user_skill.priority = 'medium'++ org_skill = Mock()+ org_skill.name = 'shared_skill'+ org_skill.priority = 'high'++ repo_skill = Mock()+ repo_skill.name = 'shared_skill'+ repo_skill.priority = 'highest'++ mock_load_global.return_value = [global_skill]+ mock_load_user.return_value = [user_skill]+ mock_load_org.return_value = [org_skill]+ mock_load_repo.return_value = [repo_skill]++ mock_user_context = AsyncMock()++ # Act+ global_skills = mock_load_global()+ user_skills = mock_load_user()+ org_skills = await mock_load_org(+ mock_async_remote_workspace, 'owner/repo', '/workspace', mock_user_context+ )+ repo_skills = await mock_load_repo(+ mock_async_remote_workspace, 'owner/repo', '/workspace'+ )++ # Merge with correct precedence: global < user < org < repo+ all_skills = merge_skills([global_skills, user_skills, org_skills, repo_skills])++ # Assert+ assert len(all_skills) == 1+ assert all_skills[0].priority == 'highest' # Repo has highest precedence++ @pytest.mark.asyncio+ @patch('openhands.app_server.app_conversation.skill_loader.load_global_skills')+ @patch('openhands.sdk.context.skills.load_user_skills')+ @patch('openhands.app_server.app_conversation.skill_loader.load_org_skills')+ @patch('openhands.app_server.app_conversation.skill_loader.load_repo_skills')+ async def test_loading_org_skills_with_unique_names(+ self,+ mock_load_repo,+ mock_load_org,+ mock_load_user,+ mock_load_global,+ mock_async_remote_workspace,+ ):+ """Test loading org skills with unique names alongside other sources."""+ # Arrange+ global_skill = Mock()+ global_skill.name = 'global_skill'++ user_skill = Mock()+ user_skill.name = 'user_skill'++ org_skill = Mock()+ org_skill.name = 'org_skill'++ repo_skill = Mock()+ repo_skill.name = 'repo_skill'++ mock_load_global.return_value = [global_skill]+ mock_load_user.return_value = [user_skill]+ mock_load_org.return_value = [org_skill]+ mock_load_repo.return_value = [repo_skill]++ mock_user_context = AsyncMock()++ # Act+ global_skills = mock_load_global()+ user_skills = mock_load_user()+ org_skills = await mock_load_org(+ mock_async_remote_workspace, 'owner/repo', '/workspace', mock_user_context+ )+ repo_skills = await mock_load_repo(+ mock_async_remote_workspace, 'owner/repo', '/workspace'+ )++ all_skills = merge_skills([global_skills, user_skills, org_skills, repo_skills])++ # Assert+ assert len(all_skills) == 4+ names = {s.name for s in all_skills}+ assert names == {'global_skill', 'user_skill', 'org_skill', 'repo_skill'}