usecli 0.1.33__tar.gz → 0.1.35__tar.gz

{usecli-0.1.33 → usecli-0.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usecli
-Version: 0.1.33
+Version: 0.1.35
 Summary: A powerful Python CLI framework for building beautiful, developer-friendly command-line tools.
 Author: Edward Boswell
 Author-email: Edward Boswell <thememium@gmail.com>
@@ -190,8 +190,10 @@ make:command Create new command
 
 ### Hiding Built-in Commands
 
+Add this to `usecli.config.toml`:
+
 ```toml
-[tool.usecli]
+[usecli]
 hide_init = true
 hide_inspire = true
 ```

{usecli-0.1.33 → usecli-0.1.35}/README.md

@@ -161,8 +161,10 @@ make:command Create new command
 
 ### Hiding Built-in Commands
 
+Add this to `usecli.config.toml`:
+
 ```toml
-[tool.usecli]
+[usecli]
 hide_init = true
 hide_inspire = true
 ```

{usecli-0.1.33 → usecli-0.1.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.33"
+version = "0.1.35"
 description = "A powerful Python CLI framework for building beautiful, developer-friendly command-line tools."
 readme = "README.md"
 authors = [{ name = "Edward Boswell", email = "thememium@gmail.com" }]
@@ -81,11 +81,6 @@ exclude = ["**/__pycache__", "**/.venv"]
 # Ty uses rule = "level" format (error, warn, ignore)
 # See all rules at: https://docs.astral.sh/ty/reference/rules/
 
-[tool.usecli]
-theme = "default"
-commands_dir = "src/usecli/cli/commands/custom"
-templates_dir = "src/usecli/cli/templates"
-themes_dir = "src/usecli/cli/themes"
-hide_init = false
-hide_inspire = false
-hide_make_command = false
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cli*"]

{usecli-0.1.33 → usecli-0.1.35}/src/usecli/cli/commands/init_command.py

@@ -27,7 +27,7 @@ from usecli.cli.core.base_command import BaseCommand
 from usecli.cli.core.exceptions import UsecliBadParameter
 from usecli.cli.core.validators import validate_command_name
 from usecli.cli.utils.interactive.terminal_menu import terminal_menu
-from usecli.shared.config.globals import TEMPLATES_DIR, THEMES_DIR, USECLI_TOML
+from usecli.shared.config.globals import TEMPLATES_DIR, THEMES_DIR, USECLI_CONFIG_TOML
 from usecli.shared.config.manager import ConfigManager, get_config
 
 console = Console()
@@ -44,27 +44,6 @@ class InitCommand(BaseCommand):
     def description(self) -> str:
         return "Initialize usecli in the current project"
 
-    def _replace_config_in_pyproject(
-        self, pyproject_path: Path, config_content: str
-    ) -> None:
-        """Replace existing [tool.usecli] section in pyproject.toml."""
-        content = pyproject_path.read_text()
-
-        # Pattern to match [tool.usecli] section until next section or end of file
-        pattern = r"\[tool\.usecli\].*?(?=\n\[|\Z)"
-        replacement = config_content.rstrip() + "\n"
-
-        # Replace the existing section
-        new_content = re.sub(pattern, replacement, content, flags=re.DOTALL)
-
-        pyproject_path.write_text(new_content)
-
-    def _get_config_source(self, pyproject_path: Path) -> str | None:
-        """Get the source of existing config."""
-        if pyproject_path.exists() and "[tool.usecli]" in pyproject_path.read_text():
-            return "pyproject.toml"
-        return None
-
     def _ensure_build_system(self, pyproject_path: Path) -> bool:
         if not pyproject_path.exists():
             return False
@@ -102,25 +81,21 @@ class InitCommand(BaseCommand):
             f'include = ["{root_package}*"]\n\n'
         )
 
-        if "[tool.usecli]" in content:
-            content = content.replace(
-                "[tool.usecli]",
-                f"{discovery_block}[tool.usecli]",
-            )
-        else:
-            content = content.rstrip() + f"\n\n{discovery_block}"
+        content = content.rstrip() + f"\n\n{discovery_block}"
 
         pyproject_path.write_text(content)
         return True
 
-    def _write_usecli_toml(
-        self, project_root: Path, config_content: str, force: bool
+    def _write_usecli_config(
+        self,
+        config_path: Path,
+        config_content: str,
+        force: bool,
     ) -> str:
-        config_path = project_root / USECLI_TOML
         existed = config_path.exists()
         if existed and not force:
             should_overwrite = Confirm.ask(
-                f"[{COLOR.WARNING}]usecli.toml already exists at {config_path}.[/{COLOR.WARNING}]\n"
+                f"[{COLOR.WARNING}]usecli.config.toml already exists at {config_path}.[/{COLOR.WARNING}]\n"
                 "Overwrite it with the new settings from this init run?",
                 default=False,
             )
@@ -130,6 +105,14 @@ class InitCommand(BaseCommand):
         config_path.write_text(config_content.rstrip() + "\n")
         return "updated" if existed else "created"
 
+    def _resolve_config_path(self, value: str, project_root: Path) -> Path:
+        path = Path(value).expanduser()
+        if not path.is_absolute():
+            path = project_root / path
+        if path.exists() and path.is_dir():
+            return (path / USECLI_CONFIG_TOML).resolve()
+        return path.resolve()
+
     def _ensure_project_scripts(
         self, pyproject_path: Path, command_name: str, force: bool
     ) -> str:
@@ -466,7 +449,6 @@ class InitCommand(BaseCommand):
         title: str,
         description: str,
         commands_dir: str,
-        config_content: str,
     ) -> None:
         parts = Path(commands_dir).parts
         root_package = parts[0] if parts else "src"
@@ -493,8 +475,7 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["{root_package}*"]
-
-{config_content}'''
+'''
 
         pyproject_path.write_text(pyproject_content)
 
@@ -612,21 +593,6 @@ include = ["{root_package}*"]
         console.print()
         console.print(f"[{COLOR.PRIMARY}]{title_text}")
 
-        # Check if config already exists
-        existing_source = self._get_config_source(pyproject_path)
-
-        if existing_source and not force:
-            should_overwrite = Confirm.ask(
-                f"[{COLOR.WARNING}]usecli config already exists in {existing_source}.[/{COLOR.WARNING}]\n"
-                "Overwrite it with the new settings from this init run?",
-                default=False,
-            )
-            if not should_overwrite:
-                console.print(
-                    f"[{COLOR.WARNING}]Skipping config update.[/{COLOR.WARNING}]"
-                )
-                return
-
         # Create the commands directory
         if not commands_path.exists():
             commands_path.mkdir(parents=True, exist_ok=True)
@@ -686,7 +652,9 @@ include = ["{root_package}*"]
             )
 
         # Load the template
-        template_path = Path(__file__).parent.parent / "templates" / "usecli.toml.j2"
+        template_path = (
+            Path(__file__).parent.parent / "templates" / "usecli.config.toml.j2"
+        )
         template_content = template_path.read_text()
         template = Template(template_content)
 
@@ -702,23 +670,10 @@ include = ["{root_package}*"]
         )
 
         scripts_status: str | None = None
-        usecli_toml_status: str | None = None
+        usecli_config_status: str | None = None
 
         # Check if pyproject.toml exists
         if pyproject_path.exists():
-            content = pyproject_path.read_text()
-            if "[tool.usecli]" in content:
-                self._replace_config_in_pyproject(pyproject_path, config_content)
-                console.print(
-                    f"[{COLOR.SUCCESS}]Updated [tool.usecli] in {pyproject_path}[/{COLOR.SUCCESS}]"
-                )
-            else:
-                with open(pyproject_path, "a") as f:
-                    f.write("\n\n" + config_content)
-                console.print(
-                    f"[{COLOR.SUCCESS}]Added [tool.usecli] to {pyproject_path}[/{COLOR.SUCCESS}]"
-                )
-
             scripts_status = self._ensure_project_scripts(
                 pyproject_path, command_name, force
             )
@@ -753,7 +708,6 @@ include = ["{root_package}*"]
                 title,
                 description,
                 commands_dir,
-                config_content,
             )
             console.print(
                 f"[{COLOR.SUCCESS}]Created {pyproject_path}[/{COLOR.SUCCESS}]"
@@ -762,20 +716,48 @@ include = ["{root_package}*"]
 
             self._sync_environment(project_root, command_name)
 
-        usecli_toml_status = self._write_usecli_toml(
-            project_root, config_content, force
+        config_root = project_root
+        if commands_path.parent != project_root:
+            config_root = commands_path.parent
+        existing_config = ConfigManager(start_dir=config_root).usecli_config_path
+        default_config_path = (
+            existing_config
+            if existing_config.exists()
+            else config_root / USECLI_CONFIG_TOML
+        )
+        config_location = Prompt.ask(
+            f"[bold {COLOR.SECONDARY}]Config file location[/bold {COLOR.SECONDARY}]"
+            " (path or directory)",
+            default=str(default_config_path),
+        )
+        config_path = self._resolve_config_path(config_location, project_root)
+        if (
+            existing_config.exists()
+            and config_path.resolve() != existing_config.resolve()
+            and not force
+        ):
+            replace_existing = Confirm.ask(
+                f"[{COLOR.WARNING}]Existing {USECLI_CONFIG_TOML} found at {existing_config}.[/{COLOR.WARNING}]\n"
+                "Replace it instead of writing to the new location?",
+                default=False,
+            )
+            if replace_existing:
+                config_path = existing_config
+
+        usecli_config_status = self._write_usecli_config(
+            config_path, config_content, force
         )
-        if usecli_toml_status == "created":
+        if usecli_config_status == "created":
             console.print(
-                f"[{COLOR.SUCCESS}]Created {USECLI_TOML} for runtime config fallback[/{COLOR.SUCCESS}]"
+                f"[{COLOR.SUCCESS}]Created {USECLI_CONFIG_TOML} for runtime config fallback[/{COLOR.SUCCESS}]"
             )
-        elif usecli_toml_status == "updated":
+        elif usecli_config_status == "updated":
             console.print(
-                f"[{COLOR.SUCCESS}]Updated {USECLI_TOML} for runtime config fallback[/{COLOR.SUCCESS}]"
+                f"[{COLOR.SUCCESS}]Updated {USECLI_CONFIG_TOML} for runtime config fallback[/{COLOR.SUCCESS}]"
             )
-        elif usecli_toml_status == "skipped":
+        elif usecli_config_status == "skipped":
             console.print(
-                f"[{COLOR.WARNING}]Skipped updating {USECLI_TOML}.[/{COLOR.WARNING}]"
+                f"[{COLOR.WARNING}]Skipped updating {USECLI_CONFIG_TOML}.[/{COLOR.WARNING}]"
             )
 
         # Show summary

{usecli-0.1.33 → usecli-0.1.35}/src/usecli/cli/config/colors.py

@@ -22,7 +22,7 @@ else:
 
 
 PYPROJECT_TOML = "pyproject.toml"
-USECLI_TOML = "usecli.toml"
+USECLI_CONFIG_TOML = "usecli.config.toml"
 DEFAULT_THEME_NAME = "default"
 THEMES_DIR = Path(__file__).resolve().parent.parent / "themes"
 DEFAULT_THEME_COLORS: dict[str, str] = {
@@ -48,55 +48,101 @@ DEFAULT_THEME_COLORS: dict[str, str] = {
 }
 
 
+def _find_usecli_config_path(root_dir: Path, start_dir: Path) -> Path | None:
+    if not root_dir.exists() or not root_dir.is_dir():
+        return None
+
+    candidates = [
+        path
+        for path in root_dir.rglob(USECLI_CONFIG_TOML)
+        if not any(part in {".venv", "venv"} for part in path.parts)
+    ]
+    if not candidates:
+        return None
+
+    start_dir = start_dir.resolve()
+    preferred: list[Path] = []
+    for path in candidates:
+        try:
+            path.relative_to(start_dir)
+            preferred.append(path)
+        except ValueError:
+            continue
+
+    selection = preferred or candidates
+
+    def _depth_key(path: Path) -> tuple[int, str]:
+        try:
+            relative = path.relative_to(start_dir)
+            return (len(relative.parts), str(path))
+        except ValueError:
+            relative = path.relative_to(root_dir)
+            return (len(relative.parts), str(path))
+
+    selection.sort(key=_depth_key)
+    return selection[0]
+
+
 def _find_project_root(start_dir: Path | None = None) -> Path | None:
     if start_dir is None:
         start_dir = Path.cwd()
 
     current = start_dir.resolve()
+    git_root: Path | None = None
 
     while True:
         pyproject_path = current / PYPROJECT_TOML
         if pyproject_path.exists():
             return current
 
-        usecli_path = current / USECLI_TOML
+        usecli_path = current / USECLI_CONFIG_TOML
         if usecli_path.exists():
             return current
 
         git_dir = current / ".git"
         if git_dir.exists():
-            return current
+            git_root = current
+            break
 
         parent = current.parent
         if parent == current:
             break
         current = parent
 
-    return None
+    search_root = git_root or start_dir.resolve()
+    config_match = _find_usecli_config_path(search_root, start_dir)
+    if config_match:
+        return config_match.parent
+
+    return git_root
 
 
 def _load_usecli_config(project_root: Path | None) -> dict[str, Any]:
     if project_root is None:
         return {}
 
-    pyproject_path = project_root / PYPROJECT_TOML
-    if not pyproject_path.exists():
+    config_path = project_root / USECLI_CONFIG_TOML
+    if not config_path.exists():
+        config_path = _find_usecli_config_path(project_root, project_root)
+    if not config_path or not config_path.exists():
         return {}
 
     try:
-        data = tomllib.loads(pyproject_path.read_text())
+        data = tomllib.loads(config_path.read_text())
     except (tomllib.TOMLDecodeError, OSError):
         return {}
 
     tool = data.get("tool", {})
-    if not isinstance(tool, dict):
-        return {}
+    if isinstance(tool, dict) and "usecli" in tool:
+        usecli_config = tool.get("usecli")
+        if isinstance(usecli_config, dict):
+            return usecli_config
 
-    usecli_config = tool.get("usecli", {})
-    if not isinstance(usecli_config, dict):
-        return {}
+    usecli_section = data.get("usecli", {})
+    if isinstance(usecli_section, dict):
+        return usecli_section
 
-    return usecli_config
+    return {}
 
 
 def _normalize_color(value: Any) -> str | None:

usecli-0.1.33/src/usecli/cli/templates/usecli.toml.j2 → usecli-0.1.35/src/usecli/cli/templates/usecli.config.toml.j2

@@ -1,4 +1,4 @@
-[tool.usecli]
+[usecli]
 title = "{{ title | default('My CLI') }}"
 title_file = "{{ title_file | default('') }}"
 title_font = "{{ title_font | default('big') }}"

usecli-0.1.35/src/usecli/cli/usecli.config.toml

@@ -0,0 +1,13 @@
+[usecli]
+title = "usecli"
+title_file = ""
+title_font = "ansi_shadow"
+description = "A custom CLI tool"
+commands_dir = "src/usecli/cli/commands/custom"
+templates_dir = "src/usecli/cli/templates"
+themes_dir = "src/usecli/cli/themes"
+theme = "default"
+hide_init = false
+hide_inspire = false
+hide_make_command = false
+hide_make_theme = false

{usecli-0.1.33 → usecli-0.1.35}/src/usecli/shared/config/globals.py

@@ -17,4 +17,4 @@ THEMES_DIR = CLI_ROOT / "themes"
 
 # Config file names
 PYPROJECT_TOML = "pyproject.toml"
-USECLI_TOML = "usecli.toml"
+USECLI_CONFIG_TOML = "usecli.config.toml"

{usecli-0.1.33 → usecli-0.1.35}/src/usecli/shared/config/manager.py

@@ -1,8 +1,6 @@
 """Configuration manager for useCli CLI.
 
 Handles loading and accessing configuration from project-level files.
-Configuration is loaded from (in priority order):
-  1. pyproject.toml [tool.usecli] section (preferred for Python projects)
 """
 
 from __future__ import annotations
@@ -12,7 +10,7 @@ from pathlib import Path
 from typing import Any
 
 from usecli.cli.core.exceptions.config import UsecliConfigError
-from usecli.shared.config.globals import PYPROJECT_TOML, USECLI_TOML
+from usecli.shared.config.globals import PYPROJECT_TOML, USECLI_CONFIG_TOML
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -58,16 +56,9 @@ def _dedupe_items(items: list[str]) -> list[str]:
 
 
 class ConfigManager:
-    """Manages useCli configuration from project-level files.
+    """Manages useCli configuration from project-level files."""
 
-    Configuration is loaded from:
-    1. pyproject.toml [tool.usecli] in current directory (highest priority)
-    2. Default values (lowest priority)
-
-    Attributes:
-        pyproject_path: Path to pyproject.toml in current directory.
-        _config: The merged configuration dictionary.
-    """
+    _SKIP_DIRS = {".venv", "venv"}
 
     DEFAULT_CONFIG: dict[str, Any] = {
         "title": "usecli",
@@ -88,7 +79,7 @@ class ConfigManager:
     def __init__(
         self,
         pyproject_path: Path | None = None,
-        usecli_toml_path: Path | None = None,
+        usecli_config_path: Path | None = None,
         start_dir: Path | None = None,
     ) -> None:
         """Initialize the configuration manager.
@@ -107,17 +98,17 @@ class ConfigManager:
                 start_dir / PYPROJECT_TOML
             )
 
-        if usecli_toml_path is None:
-            usecli_toml_path = self._find_usecli_toml(start_dir) or (
-                start_dir / USECLI_TOML
+        if usecli_config_path is None:
+            usecli_config_path = self._find_usecli_config(start_dir) or (
+                start_dir / USECLI_CONFIG_TOML
             )
 
         self.pyproject_path: Path = pyproject_path
-        self.usecli_toml_path: Path = usecli_toml_path
+        self.usecli_config_path: Path = usecli_config_path
         self.start_dir: Path = start_dir
         detected_root = find_project_root(start_dir)
-        if detected_root is None and self.usecli_toml_path.exists():
-            detected_root = self.usecli_toml_path.parent
+        if detected_root is None and self.usecli_config_path.exists():
+            detected_root = self.usecli_config_path.parent
         self.project_root: Path = (detected_root or start_dir).resolve()
         self._config: dict[str, Any] = {}
         self._overrides: dict[str, Any] = {}
@@ -128,30 +119,16 @@ class ConfigManager:
         self._config = self.DEFAULT_CONFIG.copy()
         self._overrides = {}
 
-        loaded = False
-        if self.pyproject_path.exists():
-            try:
-                pyproject_config = self._load_pyproject_toml(self.pyproject_path)
-                if pyproject_config:
-                    self._config = _deep_merge(self._config, pyproject_config)
-                    self._overrides = _deep_merge(self._overrides, pyproject_config)
-                    loaded = True
-            except (tomllib.TOMLDecodeError, OSError) as e:
-                raise UsecliConfigError(
-                    f"Failed to load pyproject.toml: {e}",
-                    config_file=str(self.pyproject_path),
-                ) from e
-
-        if not loaded and self.usecli_toml_path.exists():
+        if self.usecli_config_path.exists():
             try:
-                usecli_config = self._load_usecli_toml(self.usecli_toml_path)
+                usecli_config = self._load_usecli_toml(self.usecli_config_path)
                 if usecli_config:
                     self._config = _deep_merge(self._config, usecli_config)
                     self._overrides = _deep_merge(self._overrides, usecli_config)
             except (tomllib.TOMLDecodeError, OSError) as e:
                 raise UsecliConfigError(
-                    f"Failed to load usecli.toml: {e}",
-                    config_file=str(self.usecli_toml_path),
+                    f"Failed to load {USECLI_CONFIG_TOML}: {e}",
+                    config_file=str(self.usecli_config_path),
                 ) from e
 
         default_themes = _normalize_themes_dir(self.DEFAULT_CONFIG.get("themes_dir"))
@@ -188,11 +165,11 @@ class ConfigManager:
         return None
 
     @classmethod
-    def _find_usecli_toml(cls, start_dir: Path) -> Path | None:
+    def _find_usecli_config(cls, start_dir: Path) -> Path | None:
         current = start_dir.resolve()
 
         while True:
-            config_path = current / USECLI_TOML
+            config_path = current / USECLI_CONFIG_TOML
             if config_path.exists():
                 return config_path
 
@@ -201,46 +178,72 @@ class ConfigManager:
                 break
             current = parent
 
-        return cls._find_usecli_toml_on_sys_path()
+        search_root = find_project_root(start_dir) or start_dir.resolve()
+        recursive_match = cls._find_usecli_config_in_tree(search_root, start_dir)
+        if recursive_match:
+            return recursive_match
+
+        return cls._find_usecli_config_on_sys_path()
 
     @staticmethod
-    def _find_usecli_toml_on_sys_path() -> Path | None:
+    def _find_usecli_config_in_tree(root_dir: Path, start_dir: Path) -> Path | None:
+        if not root_dir.exists() or not root_dir.is_dir():
+            return None
+
+        candidates = [
+            path
+            for path in root_dir.rglob(USECLI_CONFIG_TOML)
+            if not any(part in ConfigManager._SKIP_DIRS for part in path.parts)
+        ]
+        if not candidates:
+            return None
+
+        start_dir = start_dir.resolve()
+        preferred: list[Path] = []
+        for path in candidates:
+            try:
+                path.relative_to(start_dir)
+                preferred.append(path)
+            except ValueError:
+                continue
+
+        selection = preferred or candidates
+
+        def _depth_key(path: Path) -> tuple[int, str]:
+            try:
+                relative = path.relative_to(start_dir)
+                return (len(relative.parts), str(path))
+            except ValueError:
+                relative = path.relative_to(root_dir)
+                return (len(relative.parts), str(path))
+
+        selection.sort(key=_depth_key)
+        return selection[0]
+
+    @staticmethod
+    def _find_usecli_config_on_sys_path() -> Path | None:
         for entry in sys.path:
             if not entry:
                 continue
             path = Path(entry)
             if not path.exists() or not path.is_dir():
                 continue
-            candidate = path / USECLI_TOML
+            candidate = path / USECLI_CONFIG_TOML
             if candidate.exists():
                 return candidate
-            for child in path.glob(f"*/{USECLI_TOML}"):
+            for child in path.glob(f"*/{USECLI_CONFIG_TOML}"):
                 if child.exists():
                     return child
         return None
 
-    @staticmethod
-    def _load_pyproject_toml(path: Path) -> dict[str, Any]:
-        """Load pyproject.toml and return [tool.usecli] section.
-
-        Args:
-            path: Path to the pyproject.toml file.
-
-        Returns:
-            Parsed [tool.usecli] content as a dictionary, or empty dict.
-        """
-        with open(path, "rb") as f:
-            data = tomllib.load(f)
-            return data.get("tool", {}).get("usecli", {})
-
     @staticmethod
     def _load_usecli_toml(path: Path) -> dict[str, Any]:
         with open(path, "rb") as f:
             data = tomllib.load(f)
 
         tool_section = data.get("tool", {})
-        if isinstance(tool_section, dict):
-            usecli_section = tool_section.get("usecli", {})
+        if isinstance(tool_section, dict) and "usecli" in tool_section:
+            usecli_section = tool_section.get("usecli")
             if isinstance(usecli_section, dict):
                 return usecli_section
 
@@ -329,14 +332,7 @@ class ConfigManager:
 
     @property
     def pyproject_exists(self) -> bool:
-        """Check if pyproject.toml with [tool.usecli] exists."""
-        if self.pyproject_path.exists() and self._pyproject_has_usecli(
-            self.pyproject_path
-        ):
-            return True
-        if self.usecli_toml_path.exists():
-            return True
-        return False
+        return self.usecli_config_path.exists()
 
     @staticmethod
     def _load_project_version(path: Path) -> str | None:
@@ -382,22 +378,29 @@ def find_project_root(start_dir: Path | None = None) -> Path | None:
 
     current = start_dir.resolve()
 
+    git_root: Path | None = None
     while True:
         pyproject_path = current / PYPROJECT_TOML
         if pyproject_path.exists():
             return current
 
-        usecli_path = current / USECLI_TOML
+        usecli_path = current / USECLI_CONFIG_TOML
         if usecli_path.exists():
             return current
 
         git_dir = current / ".git"
         if git_dir.exists():
-            return current
+            git_root = current
+            break
 
         parent = current.parent
         if parent == current:
             break
         current = parent
 
-    return None
+    search_root = git_root or start_dir.resolve()
+    config_match = ConfigManager._find_usecli_config_in_tree(search_root, start_dir)
+    if config_match:
+        return config_match.parent
+
+    return git_root