usecli 0.1.34__tar.gz → 0.1.36__tar.gz

{usecli-0.1.34 → usecli-0.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usecli
-Version: 0.1.34
+Version: 0.1.36
 Summary: A powerful Python CLI framework for building beautiful, developer-friendly command-line tools.
 Author: Edward Boswell
 Author-email: Edward Boswell <thememium@gmail.com>

{usecli-0.1.34 → usecli-0.1.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.34"
+version = "0.1.36"
 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" }]

{usecli-0.1.34 → usecli-0.1.36}/src/usecli/cli/commands/init_command.py

@@ -88,18 +88,10 @@ class InitCommand(BaseCommand):
 
     def _write_usecli_config(
         self,
-        project_root: Path,
+        config_path: Path,
         config_content: str,
         force: bool,
-        commands_path: Path,
     ) -> str:
-        config_root = project_root
-        if commands_path.parent != project_root:
-            config_root = commands_path.parent
-        config_path = config_root / USECLI_CONFIG_TOML
-        discovered_config = ConfigManager(start_dir=config_root).usecli_config_path
-        if discovered_config.exists():
-            config_path = discovered_config
         existed = config_path.exists()
         if existed and not force:
             should_overwrite = Confirm.ask(
@@ -113,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:
@@ -716,8 +716,36 @@ include = ["{root_package}*"]
 
             self._sync_environment(project_root, command_name)
 
+        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(
-            project_root, config_content, force, commands_path
+            config_path, config_content, force
         )
         if usecli_config_status == "created":
             console.print(

{usecli-0.1.34 → usecli-0.1.36}/src/usecli/cli/config/colors.py

@@ -11,6 +11,7 @@ Usage:
 
 from __future__ import annotations
 
+import importlib.util
 import sys
 from pathlib import Path
 from typing import Any, Callable, Final, final
@@ -25,6 +26,7 @@ PYPROJECT_TOML = "pyproject.toml"
 USECLI_CONFIG_TOML = "usecli.config.toml"
 DEFAULT_THEME_NAME = "default"
 THEMES_DIR = Path(__file__).resolve().parent.parent / "themes"
+_PACKAGE_PREFER_DIRS = {".venv", "venv", "site-packages"}
 DEFAULT_THEME_COLORS: dict[str, str] = {
     "primary": "#60D7FF",
     "secondary": "#5EFF87",
@@ -48,11 +50,19 @@ DEFAULT_THEME_COLORS: dict[str, str] = {
 }
 
 
-def _find_usecli_config_path(root_dir: Path, start_dir: Path) -> Path | None:
+def _find_usecli_config_path(
+    root_dir: Path, start_dir: Path, *, skip_venv: bool
+) -> 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 skip_venv:
+        candidates = [
+            path
+            for path in candidates
+            if not any(part in {".venv", "venv"} for part in path.parts)
+        ]
     if not candidates:
         return None
 
@@ -79,6 +89,42 @@ def _find_usecli_config_path(root_dir: Path, start_dir: Path) -> Path | None:
     return selection[0]
 
 
+def _find_usecli_config_in_package() -> Path | None:
+    spec = importlib.util.find_spec(_get_package_name())
+    if spec is None or not spec.submodule_search_locations:
+        return None
+    for location in spec.submodule_search_locations:
+        package_root = Path(location)
+        if not package_root.exists() or not package_root.is_dir():
+            continue
+        candidates = [
+            path for path in package_root.rglob(USECLI_CONFIG_TOML) if path.exists()
+        ]
+        if candidates:
+            candidates.sort(key=lambda path: (len(path.parts), str(path)))
+            return candidates[0]
+    return None
+
+
+def _is_preferred_package_path(path: Path) -> bool:
+    return any(part in _PACKAGE_PREFER_DIRS for part in path.parts)
+
+
+def _is_within_usecli_package(start_dir: Path) -> bool:
+    spec = importlib.util.find_spec(_get_package_name())
+    if spec is None or not spec.submodule_search_locations:
+        return False
+    start_dir = start_dir.resolve()
+    for location in spec.submodule_search_locations:
+        package_root = Path(location)
+        try:
+            start_dir.relative_to(package_root)
+            return True
+        except ValueError:
+            continue
+    return False
+
+
 def _find_project_root(start_dir: Path | None = None) -> Path | None:
     if start_dir is None:
         start_dir = Path.cwd()
@@ -86,6 +132,10 @@ def _find_project_root(start_dir: Path | None = None) -> Path | None:
     current = start_dir.resolve()
     git_root: Path | None = None
 
+    package_match = _find_usecli_config_in_package()
+    if package_match and _is_preferred_package_path(package_match):
+        return package_match.parent
+
     while True:
         pyproject_path = current / PYPROJECT_TOML
         if pyproject_path.exists():
@@ -106,10 +156,16 @@ def _find_project_root(start_dir: Path | None = None) -> Path | None:
         current = parent
 
     search_root = git_root or start_dir.resolve()
-    config_match = _find_usecli_config_path(search_root, start_dir)
+    config_match = _find_usecli_config_path(
+        search_root, start_dir, skip_venv=_is_within_usecli_package(start_dir)
+    )
     if config_match:
         return config_match.parent
 
+    package_match = _find_usecli_config_in_package()
+    if package_match:
+        return package_match.parent
+
     return git_root
 
 
@@ -117,12 +173,28 @@ def _load_usecli_config(project_root: Path | None) -> dict[str, Any]:
     if project_root is None:
         return {}
 
+    package_match = _find_usecli_config_in_package()
+    if package_match and _is_preferred_package_path(package_match):
+        return _load_usecli_config_file(package_match)
+
     config_path = project_root / USECLI_CONFIG_TOML
     if not config_path.exists():
-        config_path = _find_usecli_config_path(project_root, project_root)
+        config_path = _find_usecli_config_path(
+            project_root,
+            project_root,
+            skip_venv=_is_within_usecli_package(project_root),
+        )
+    if not config_path or not config_path.exists():
+        package_match = _find_usecli_config_in_package()
+        if package_match:
+            config_path = package_match
     if not config_path or not config_path.exists():
         return {}
 
+    return _load_usecli_config_file(config_path)
+
+
+def _load_usecli_config_file(config_path: Path) -> dict[str, Any]:
     try:
         data = tomllib.loads(config_path.read_text())
     except (tomllib.TOMLDecodeError, OSError):
@@ -141,6 +213,13 @@ def _load_usecli_config(project_root: Path | None) -> dict[str, Any]:
     return {}
 
 
+def _get_package_name() -> str:
+    package = __package__ or __name__
+    if not package:
+        return "usecli"
+    return package.split(".")[0]
+
+
 def _normalize_color(value: Any) -> str | None:
     if not isinstance(value, str):
         return None

{usecli-0.1.34 → usecli-0.1.36}/src/usecli/shared/config/manager.py

@@ -5,6 +5,7 @@ Handles loading and accessing configuration from project-level files.
 
 from __future__ import annotations
 
+import importlib.util
 import sys
 from pathlib import Path
 from typing import Any
@@ -58,6 +59,9 @@ def _dedupe_items(items: list[str]) -> list[str]:
 class ConfigManager:
     """Manages useCli configuration from project-level files."""
 
+    _SKIP_DIRS = {".venv", "venv"}
+    _PACKAGE_PREFER_DIRS = {".venv", "venv", "site-packages"}
+
     DEFAULT_CONFIG: dict[str, Any] = {
         "title": "usecli",
         "title_file": None,
@@ -166,6 +170,10 @@ class ConfigManager:
     def _find_usecli_config(cls, start_dir: Path) -> Path | None:
         current = start_dir.resolve()
 
+        package_match = cls._find_usecli_config_in_package()
+        if package_match and cls._is_preferred_package_path(package_match):
+            return package_match
+
         while True:
             config_path = current / USECLI_CONFIG_TOML
             if config_path.exists():
@@ -176,19 +184,33 @@ class ConfigManager:
                 break
             current = parent
 
+        in_usecli_package = cls._is_within_usecli_package(start_dir)
+        if in_usecli_package and package_match:
+            return package_match
+
         search_root = find_project_root(start_dir) or start_dir.resolve()
-        recursive_match = cls._find_usecli_config_in_tree(search_root, start_dir)
+        recursive_match = cls._find_usecli_config_in_tree(
+            search_root, start_dir, skip_venv=in_usecli_package
+        )
         if recursive_match:
             return recursive_match
 
         return cls._find_usecli_config_on_sys_path()
 
     @staticmethod
-    def _find_usecli_config_in_tree(root_dir: Path, start_dir: Path) -> Path | None:
+    def _find_usecli_config_in_tree(
+        root_dir: Path, start_dir: Path, *, skip_venv: bool
+    ) -> 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 skip_venv:
+            candidates = [
+                path
+                for path in candidates
+                if not any(part in ConfigManager._SKIP_DIRS for part in path.parts)
+            ]
         if not candidates:
             return None
 
@@ -214,6 +236,42 @@ class ConfigManager:
         selection.sort(key=_depth_key)
         return selection[0]
 
+    @staticmethod
+    def _find_usecli_config_in_package() -> Path | None:
+        spec = importlib.util.find_spec(_get_package_name())
+        if spec is None or not spec.submodule_search_locations:
+            return None
+        for location in spec.submodule_search_locations:
+            package_root = Path(location)
+            if not package_root.exists() or not package_root.is_dir():
+                continue
+            candidates = [
+                path for path in package_root.rglob(USECLI_CONFIG_TOML) if path.exists()
+            ]
+            if candidates:
+                candidates.sort(key=lambda path: (len(path.parts), str(path)))
+                return candidates[0]
+        return None
+
+    @staticmethod
+    def _is_preferred_package_path(path: Path) -> bool:
+        return any(part in ConfigManager._PACKAGE_PREFER_DIRS for part in path.parts)
+
+    @staticmethod
+    def _is_within_usecli_package(start_dir: Path) -> bool:
+        spec = importlib.util.find_spec(_get_package_name())
+        if spec is None or not spec.submodule_search_locations:
+            return False
+        start_dir = start_dir.resolve()
+        for location in spec.submodule_search_locations:
+            package_root = Path(location)
+            try:
+                start_dir.relative_to(package_root)
+                return True
+            except ValueError:
+                continue
+        return False
+
     @staticmethod
     def _find_usecli_config_on_sys_path() -> Path | None:
         for entry in sys.path:
@@ -322,6 +380,9 @@ class ConfigManager:
 
     def reload(self) -> None:
         """Reload configuration from disk."""
+        self.usecli_config_path = self._find_usecli_config(self.start_dir) or (
+            self.start_dir / USECLI_CONFIG_TOML
+        )
         self._load_config()
 
     @property
@@ -372,6 +433,10 @@ def find_project_root(start_dir: Path | None = None) -> Path | None:
 
     current = start_dir.resolve()
 
+    package_match = ConfigManager._find_usecli_config_in_package()
+    if package_match and ConfigManager._is_preferred_package_path(package_match):
+        return package_match.parent
+
     git_root: Path | None = None
     while True:
         pyproject_path = current / PYPROJECT_TOML
@@ -393,8 +458,19 @@ def find_project_root(start_dir: Path | None = None) -> Path | None:
         current = parent
 
     search_root = git_root or start_dir.resolve()
-    config_match = ConfigManager._find_usecli_config_in_tree(search_root, start_dir)
+    config_match = ConfigManager._find_usecli_config_in_tree(
+        search_root,
+        start_dir,
+        skip_venv=ConfigManager._is_within_usecli_package(start_dir),
+    )
     if config_match:
         return config_match.parent
 
     return git_root
+
+
+def _get_package_name() -> str:
+    package = __package__ or __name__
+    if not package:
+        return "usecli"
+    return package.split(".")[0]