feat: allow dbx sync to accept '.' or any path as repo argument

- Add find_repo_by_path() to utils/repo.py that resolves a filesystem
  path to a managed repo, including when called from a subdirectory
- Update sync_callback to detect path-like inputs (., .., absolute/
  relative paths) and route them through find_repo_by_path instead of
  find_repo_by_name
- Add tests for syncing from repo root, from a subdirectory, and from
  an unmanaged directory

Author: aclark4life

src/dbx_python_cli/commands/sync.py

@@ -86,7 +86,7 @@ def sync_callback(
         dbx sync -a --dry-run                           # Preview all groups sync
         dbx sync -g pymongo mongo-python-driver --dry-run  # Preview specific repo
     """
-    from dbx_python_cli.utils.repo import find_all_repos, find_repo_by_name
+    from dbx_python_cli.utils.repo import find_all_repos, find_repo_by_name, find_repo_by_path
 
     # Get verbose flag from parent context
     verbose = ctx.obj.get("verbose", False) if ctx.obj else False
@@ -269,12 +269,30 @@ def sync_callback(
             typer.echo("   or: dbx sync -g <group> <repo-name>")
             raise typer.Exit(1)
 
+        # Detect path-like inputs: ".", "..", absolute paths, relative paths with /
+        _is_path_like = (
+            repo_name in (".", "..")
+            or repo_name.startswith(("./", "../", "/", "~/"))
+            or "/" in repo_name
+            or Path(repo_name).is_dir()
+        )
+
         # Find the repository
-        repo_info = find_repo_by_name(repo_name, base_dir, config)
-        if not repo_info:
-            typer.echo(f"❌ Error: Repository '{repo_name}' not found", err=True)
-            typer.echo("\nUse 'dbx list' to see available repositories")
-            raise typer.Exit(1)
+        if _is_path_like:
+            repo_info = find_repo_by_path(repo_name, base_dir, config)
+            if not repo_info:
+                typer.echo(
+                    f"❌ Error: No managed repository found at '{Path(repo_name).resolve()}'",
+                    err=True,
+                )
+                typer.echo("\nUse 'dbx list' to see available repositories")
+                raise typer.Exit(1)
+        else:
+            repo_info = find_repo_by_name(repo_name, base_dir, config)
+            if not repo_info:
+                typer.echo(f"❌ Error: Repository '{repo_name}' not found", err=True)
+                typer.echo("\nUse 'dbx list' to see available repositories")
+                raise typer.Exit(1)
 
         _sync_repository(repo_info["path"], repo_info["name"], verbose, force, dry_run)
 

src/dbx_python_cli/utils/repo.py

@@ -629,6 +629,46 @@ def find_repo_by_name(repo_name, base_dir, config=None):
     return matching_repos[0]
 
 
+def find_repo_by_path(path, base_dir, config=None):
+    """
+    Find a repository by filesystem path.
+
+    Resolves *path* to an absolute path and checks all known repos for a
+    match.  An exact match on the repo root is tried first; if not found,
+    the function checks whether *path* is located *inside* a known repo
+    (useful when the caller is in a subdirectory of the repo).
+
+    Args:
+        path: A :class:`pathlib.Path` (or anything accepted by ``Path()``)
+              pointing at or inside the repository root.
+        base_dir: Path to the base directory containing group subdirectories.
+        config: Optional configuration dictionary.
+
+    Returns:
+        dict: Dictionary with ``'name'``, ``'path'``, and ``'group'`` keys,
+              or ``None`` if no matching repository is found.
+    """
+    from pathlib import Path as _Path
+
+    resolved = _Path(path).resolve()
+    all_repos = find_all_repos(base_dir, config)
+
+    # Exact match first
+    for r in all_repos:
+        if r["path"].resolve() == resolved:
+            return r
+
+    # Path is inside a repo (e.g. a subdirectory)
+    for r in all_repos:
+        try:
+            resolved.relative_to(r["path"].resolve())
+            return r
+        except ValueError:
+            continue
+
+    return None
+
+
 def find_all_repos_by_name(repo_name, base_dir, config=None):
     """
     Find all repositories with a given name in the base directory.

tests/test_repo.py

@@ -900,6 +900,133 @@ def mock_run_side_effect(*args, **kwargs):
             assert "main" in push_calls[0][0][0]
 
 
+def test_repo_sync_dot_from_repo_root(tmp_path, temp_repos_dir, monkeypatch):
+    """Test syncing with '.' resolves to the repo at the current directory."""
+    config_path = tmp_path / ".config" / "dbx-python-cli" / "config.toml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    repos_dir_str = str(temp_repos_dir).replace("\\", "/")
+    config_content = f"""
+[repo]
+base_dir = "{repos_dir_str}"
+
+[repo.groups.test]
+repos = [
+    "git@github.com:mongodb/mongo-python-driver.git",
+]
+"""
+    config_path.write_text(config_content)
+
+    # Create mock repository
+    group_dir = temp_repos_dir / "test"
+    repo_dir = group_dir / "mongo-python-driver"
+    repo_dir.mkdir(parents=True)
+    (repo_dir / ".git").mkdir()
+
+    # Change into the repo root so that "." resolves to it
+    monkeypatch.chdir(repo_dir)
+
+    with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
+        with patch("dbx_python_cli.commands.sync.subprocess.run") as mock_run:
+            mock_get_path.return_value = config_path
+
+            def mock_run_side_effect(*args, **kwargs):
+                cmd = args[0]
+                if "remote" in cmd and "add" not in cmd:
+                    return subprocess.CompletedProcess(
+                        cmd, 0, stdout="origin\nupstream\n", stderr=""
+                    )
+                elif "branch" in cmd and "--show-current" in cmd:
+                    return subprocess.CompletedProcess(cmd, 0, stdout="main\n", stderr="")
+                else:
+                    return subprocess.CompletedProcess(cmd, 0, stdout="", stderr="")
+
+            mock_run.side_effect = mock_run_side_effect
+
+            result = runner.invoke(app, ["sync", "."])
+            assert result.exit_code == 0
+            assert "Syncing mongo-python-driver" in result.stdout
+            assert "Synced and pushed successfully" in result.stdout
+
+
+def test_repo_sync_dot_from_repo_subdirectory(tmp_path, temp_repos_dir, monkeypatch):
+    """Test that '.' resolves correctly when run from inside a repo subdirectory."""
+    config_path = tmp_path / ".config" / "dbx-python-cli" / "config.toml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    repos_dir_str = str(temp_repos_dir).replace("\\", "/")
+    config_content = f"""
+[repo]
+base_dir = "{repos_dir_str}"
+
+[repo.groups.test]
+repos = [
+    "git@github.com:mongodb/mongo-python-driver.git",
+]
+"""
+    config_path.write_text(config_content)
+
+    # Create mock repository with a subdirectory
+    group_dir = temp_repos_dir / "test"
+    repo_dir = group_dir / "mongo-python-driver"
+    subdir = repo_dir / "src" / "pymongo"
+    subdir.mkdir(parents=True)
+    (repo_dir / ".git").mkdir()
+
+    # Change into a subdirectory of the repo
+    monkeypatch.chdir(subdir)
+
+    with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
+        with patch("dbx_python_cli.commands.sync.subprocess.run") as mock_run:
+            mock_get_path.return_value = config_path
+
+            def mock_run_side_effect(*args, **kwargs):
+                cmd = args[0]
+                if "remote" in cmd and "add" not in cmd:
+                    return subprocess.CompletedProcess(
+                        cmd, 0, stdout="origin\nupstream\n", stderr=""
+                    )
+                elif "branch" in cmd and "--show-current" in cmd:
+                    return subprocess.CompletedProcess(cmd, 0, stdout="main\n", stderr="")
+                else:
+                    return subprocess.CompletedProcess(cmd, 0, stdout="", stderr="")
+
+            mock_run.side_effect = mock_run_side_effect
+
+            result = runner.invoke(app, ["sync", "."])
+            assert result.exit_code == 0
+            assert "Syncing mongo-python-driver" in result.stdout
+            assert "Synced and pushed successfully" in result.stdout
+
+
+def test_repo_sync_dot_not_in_managed_repo(tmp_path, temp_repos_dir, monkeypatch):
+    """Test that '.' in an unmanaged directory gives a clear error."""
+    config_path = tmp_path / ".config" / "dbx-python-cli" / "config.toml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    repos_dir_str = str(temp_repos_dir).replace("\\", "/")
+    config_content = f"""
+[repo]
+base_dir = "{repos_dir_str}"
+
+[repo.groups.test]
+repos = [
+    "git@github.com:mongodb/mongo-python-driver.git",
+]
+"""
+    config_path.write_text(config_content)
+
+    # Change into a directory that is NOT a managed repo
+    unrelated_dir = tmp_path / "unrelated"
+    unrelated_dir.mkdir()
+    monkeypatch.chdir(unrelated_dir)
+
+    with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
+        mock_get_path.return_value = config_path
+
+        result = runner.invoke(app, ["sync", "."])
+        assert result.exit_code == 1
+        output = result.stdout + result.stderr
+        assert "No managed repository found" in output
+
+
 def test_repo_sync_group(tmp_path, temp_repos_dir):
     """Test syncing all repositories in a group."""
     config_path = tmp_path / ".config" / "dbx-python-cli" / "config.toml"