Fix git worktree detection for dda env dev start

Previously, `dda env dev start` failed when run from git worktrees with
arbitrary directory names because it assumed repository directories were
named exactly as the repository (e.g., "datadog-agent").

This commit adds git-aware repository resolution that:
- Detects git repositories using remote URL, working for both regular
  repos and worktrees regardless of directory name
- Maintains full backward compatibility with non-git directory lookup
- Handles edge cases: missing git, no remote, nested structures

Implementation:
- Added `_resolve_repository_path()` with multi-strategy resolution
- Added `_is_matching_repository()` using git remote URL detection
- Updated repository mounting to use new git-aware resolver
- Added comprehensive tests for worktree scenarios

Fixes issue where worktrees like `.worktrees/my_feature` would fail
with "Local repository not found: datadog-agent"

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: misteriaud

src/dda/env/dev/types/linux_container.py

@@ -187,15 +187,9 @@ def start(self) -> None:
                 command.extend(("--mount", mount.as_csv()))
 
             if not self.config.clone:
-                from dda.utils.fs import Path
-
-                repos_path = Path.cwd().parent
                 for repo_spec in self.config.repos:
                     repo = repo_spec.split("@")[0]
-                    repo_path = repos_path / repo
-                    if not repo_path.is_dir():
-                        self.app.abort(f"Local repository not found: {repo}")
-
+                    repo_path = self._resolve_repository_path(repo_spec)
                     command.extend(("-v", f"{repo_path}:{self.repo_path(repo)}"))
 
             for mount_spec in self.config.extra_mount_specs:
@@ -450,6 +444,93 @@ def repo_path(self, repo: str | None) -> str:
 
         return f"{self.home_dir}/repos/{repo}"
 
+    def _resolve_repository_path(self, repo_spec: str) -> Path:
+        """
+        Resolve the local path for a repository specification.
+
+        Tries multiple strategies:
+        1. Check if current directory is the requested repo (git-aware, handles worktrees)
+        2. Check parent directory for repo (backward compatible)
+        3. Search common parent directories
+
+        Args:
+            repo_spec: Repository specification (e.g., "datadog-agent" or "datadog-agent@branch")
+
+        Returns:
+            Path to the repository
+
+        Raises:
+            Aborts if repository cannot be found
+        """
+        from dda.utils.fs import Path
+
+        repo_name = repo_spec.split("@")[0]  # Strip @branch/@tag if present
+
+        # Strategy 1: Check if current directory is a git repository matching the repo name
+        cwd = Path.cwd()
+        if self._is_matching_repository(cwd, repo_name):
+            return cwd
+
+        # Strategy 2: Check parent directory (existing behavior, backward compatible)
+        parent_repo_path = cwd.parent / repo_name
+        if parent_repo_path.is_dir():
+            if self._is_matching_repository(parent_repo_path, repo_name):
+                return parent_repo_path
+            # Fallback: If not a git repo but directory exists, use it for backward compat
+            return parent_repo_path
+
+        # Strategy 3: Search up to 2 levels for common parent directories
+        current = cwd.parent.parent
+        for _ in range(2):
+            candidate = current / repo_name
+            if candidate.is_dir() and self._is_matching_repository(candidate, repo_name):
+                return candidate
+            current = current.parent
+
+        self.app.abort(
+            f"Local repository not found: {repo_name}\n"
+            f"Searched in: {cwd}, {cwd.parent}, and parent directories"
+        )
+
+    def _is_matching_repository(self, path: Path, expected_repo_name: str) -> bool:
+        """
+        Check if the given path is a git repository matching the expected repository name.
+
+        Uses git remote URL to determine the repository name, which works for:
+        - Regular repositories
+        - Git worktrees (regardless of directory name)
+        - Nested repository structures
+
+        Args:
+            path: Path to check
+            expected_repo_name: Expected repository name (e.g., "datadog-agent")
+
+        Returns:
+            True if the path is a git repository matching the expected name
+        """
+        if not path.is_dir():
+            return False
+
+        git_dir = path / ".git"
+        if not git_dir.exists():
+            return False
+
+        # Use git to get the repository name from the remote URL
+        try:
+            # Change to the target directory temporarily to get its remote
+            import os
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(path)
+                remote = self.app.tools.git.get_remote()
+                return remote.repo == expected_repo_name
+            finally:
+                os.chdir(original_cwd)
+        except Exception:
+            # Not a git repository or no remote configured
+            return False
+
     def _container_cp(self, source: str, destination: str, *args: Any) -> None:
         """Runs a `cp -r` command inside the context of the container"""
         self.run_command(["cp", "-r", f'"{source}"', f'"{destination}"', *args])

tests/env/dev/types/test_linux_container.py

@@ -1415,6 +1415,198 @@ def test_directory_to_existing_file_fails(self, linux_container, test_target_dir
                 linux_container.export_path(source="/folder1", destination=existing_file)
 
 
+class TestRepositoryResolution:
+    """Tests for git-aware repository resolution logic."""
+
+    def test_git_worktree_detection(self, dda, helpers, mocker, temp_dir, host_user_args):
+        """Test that repositories are detected in git worktrees with arbitrary directory names."""
+        # Create a git repository structure
+        repos_dir = temp_dir / "repos"
+        repos_dir.ensure_dir()
+        main_repo_dir = repos_dir / "datadog-agent"
+        main_repo_dir.ensure_dir()
+
+        # Create a worktree with a different name
+        worktrees_dir = main_repo_dir / ".worktrees"
+        worktrees_dir.ensure_dir()
+        worktree_dir = worktrees_dir / "my_feature_branch"
+        worktree_dir.ensure_dir()
+
+        # Create a .git file (worktree indicator)
+        git_file = worktree_dir / ".git"
+        git_file.write_text("gitdir: /path/to/main/.git/worktrees/my_feature_branch")
+
+        # Mock git remote detection to return the correct repository name
+        mock_remote = mocker.MagicMock()
+        mock_remote.repo = "datadog-agent"
+        mocker.patch("dda.tools.git.Git.get_remote", return_value=mock_remote)
+
+        write_server_config = mocker.patch("dda.utils.ssh.write_server_config")
+        with (
+            worktree_dir.as_cwd(),
+            helpers.hybrid_patch(
+                "subprocess.run",
+                return_values={
+                    # Start command checks the status
+                    1: CompletedProcess([], returncode=0, stdout="{}"),
+                    # Start method checks the status
+                    2: CompletedProcess([], returncode=0, stdout="{}"),
+                    # Capture image pull
+                    # Capture container run
+                    # Readiness check
+                    5: CompletedProcess([], returncode=0, stdout="Server listening on :: port 22"),
+                },
+            ) as calls,
+        ):
+            result = dda("env", "dev", "start")
+
+        result.check(
+            exit_code=0,
+            output=helpers.dedent(
+                """
+                Pulling image: datadog/agent-dev-env-linux
+                Creating and starting container: dda-linux-container-default
+                Waiting for container: dda-linux-container-default
+                """
+            ),
+        )
+
+        assert_ssh_config_written(write_server_config, "localhost")
+
+        # Verify that the worktree directory (not parent/datadog-agent) is mounted
+        shared_dir = temp_dir / "data" / "env" / "dev" / "linux-container" / "default" / ".shared"
+        global_shared_dir = shared_dir.parent.parent / ".shared"
+        starship_mount = get_starship_mount(global_shared_dir)
+        cache_volumes = get_cache_volumes()
+
+        # Check that the docker run command includes the worktree directory
+        docker_run_call = calls[1]
+        assert "-v" in docker_run_call[0][0]
+        mount_arg_idx = docker_run_call[0][0].index("-v")
+        # Find the repo mount (should be the worktree directory)
+        repo_mounts = [
+            docker_run_call[0][0][i+1]
+            for i, arg in enumerate(docker_run_call[0][0])
+            if arg == "-v" and ":/root/repos/datadog-agent" in docker_run_call[0][0][i+1]
+        ]
+        assert len(repo_mounts) == 1
+        assert str(worktree_dir) in repo_mounts[0]
+
+    def test_current_directory_is_repo(self, dda, helpers, mocker, temp_dir, host_user_args):
+        """Test that the current directory is used if it's a matching git repository."""
+        repos_dir = temp_dir / "repos"
+        repos_dir.ensure_dir()
+        repo_dir = repos_dir / "datadog-agent"
+        repo_dir.ensure_dir()
+
+        # Create a .git directory
+        git_dir = repo_dir / ".git"
+        git_dir.ensure_dir()
+
+        # Mock git remote detection
+        mock_remote = mocker.MagicMock()
+        mock_remote.repo = "datadog-agent"
+        mocker.patch("dda.tools.git.Git.get_remote", return_value=mock_remote)
+
+        write_server_config = mocker.patch("dda.utils.ssh.write_server_config")
+        with (
+            repo_dir.as_cwd(),
+            helpers.hybrid_patch(
+                "subprocess.run",
+                return_values={
+                    # Start command checks the status
+                    1: CompletedProcess([], returncode=0, stdout="{}"),
+                    # Start method checks the status
+                    2: CompletedProcess([], returncode=0, stdout="{}"),
+                    # Capture image pull
+                    # Capture container run
+                    # Readiness check
+                    5: CompletedProcess([], returncode=0, stdout="Server listening on :: port 22"),
+                },
+            ) as calls,
+        ):
+            result = dda("env", "dev", "start")
+
+        result.check(exit_code=0)
+
+        # Verify the current directory is used
+        docker_run_call = calls[1]
+        repo_mounts = [
+            docker_run_call[0][0][i+1]
+            for i, arg in enumerate(docker_run_call[0][0])
+            if arg == "-v" and ":/root/repos/datadog-agent" in docker_run_call[0][0][i+1]
+        ]
+        assert len(repo_mounts) == 1
+        assert str(repo_dir) in repo_mounts[0]
+
+    def test_backward_compatibility_non_git_directory(self, dda, helpers, mocker, temp_dir, host_user_args):
+        """Test backward compatibility: non-git directories are still found via parent directory."""
+        repos_dir = temp_dir / "repos"
+        repos_dir.ensure_dir()
+        repo_dir = repos_dir / "datadog-agent"
+        repo_dir.ensure_dir()
+
+        # Don't create .git directory - this is a non-git directory
+        # Mock git to fail (no remote available)
+        mocker.patch("dda.tools.git.Git.get_remote", side_effect=Exception("Not a git repository"))
+
+        write_server_config = mocker.patch("dda.utils.ssh.write_server_config")
+        with (
+            repo_dir.as_cwd(),
+            helpers.hybrid_patch(
+                "subprocess.run",
+                return_values={
+                    # Start command checks the status
+                    1: CompletedProcess([], returncode=0, stdout="{}"),
+                    # Start method checks the status
+                    2: CompletedProcess([], returncode=0, stdout="{}"),
+                    # Capture image pull
+                    # Capture container run
+                    # Readiness check
+                    5: CompletedProcess([], returncode=0, stdout="Server listening on :: port 22"),
+                },
+            ) as calls,
+        ):
+            result = dda("env", "dev", "start")
+
+        result.check(exit_code=0)
+
+        # Verify that the parent directory lookup worked
+        docker_run_call = calls[1]
+        repo_mounts = [
+            docker_run_call[0][0][i+1]
+            for i, arg in enumerate(docker_run_call[0][0])
+            if arg == "-v" and ":/root/repos/datadog-agent" in docker_run_call[0][0][i+1]
+        ]
+        assert len(repo_mounts) == 1
+        assert str(repo_dir) in repo_mounts[0]
+
+    def test_repo_not_found_error(self, dda, helpers, mocker, temp_dir):
+        """Test that appropriate error is shown when repository cannot be found."""
+        # Don't create any repository directory
+        mocker.patch("dda.tools.git.Git.get_remote", side_effect=Exception("Not a git repository"))
+
+        with (
+            temp_dir.as_cwd(),
+            helpers.hybrid_patch(
+                "subprocess.run",
+                return_values={
+                    # Start command checks the status
+                    1: CompletedProcess([], returncode=0, stdout="{}"),
+                    # Start method checks the status
+                    2: CompletedProcess([], returncode=0, stdout="{}"),
+                },
+            ),
+        ):
+            result = dda("env", "dev", "start")
+
+        result.check(
+            exit_code=1,
+            output=mocker.ANY,  # Just check it errors, message may vary
+        )
+        assert "Local repository not found: datadog-agent" in result.output
+
+
 class TestImportFiles:
     """Basic import operations."""