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,81 @@ 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)
+
+        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
+
+        self.app.abort(f"Local repository not found: {repo_name}")
+
+    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,39 @@ 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_current_directory(self, app, mocker, temp_dir):
+        """Test git worktree with arbitrary directory name is detected as current directory."""
+        worktree_dir = temp_dir / "my_feature_branch"
+        worktree_dir.ensure_dir()
+        (worktree_dir / ".git").touch()
+
+        mock_remote = mocker.MagicMock()
+        mock_remote.repo = "datadog-agent"
+        mocker.patch.object(app.tools.git, "get_remote", return_value=mock_remote)
+
+        container = LinuxContainer(app=app, name="test", instance="test")
+        with worktree_dir.as_cwd():
+            resolved = container._resolve_repository_path("datadog-agent")
+
+        assert resolved == worktree_dir
+
+    def test_backward_compatibility_parent_directory(self, app, mocker, temp_dir):
+        """Test non-git directory is found via parent/repo_name (backward compatible)."""
+        repo_dir = temp_dir / "datadog-agent"
+        repo_dir.ensure_dir()
+
+        mocker.patch.object(app.tools.git, "get_remote", side_effect=Exception("Not a git repo"))
+
+        container = LinuxContainer(app=app, name="test", instance="test")
+        with repo_dir.as_cwd():
+            resolved = container._resolve_repository_path("datadog-agent")
+
+        assert resolved == repo_dir
+
+
 class TestImportFiles:
     """Basic import operations."""