usecli 0.1.32__tar.gz → 0.1.34__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usecli
-Version: 0.1.32
+Version: 0.1.34
 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.32 → usecli-0.1.34}/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.32 → usecli-0.1.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.32"
+version = "0.1.34"
 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.32 → usecli-0.1.34}/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
+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,17 +81,38 @@ 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_config(
+        self,
+        project_root: 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(
+                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,
+            )
+            if not should_overwrite:
+                return "skipped"
+
+        config_path.write_text(config_content.rstrip() + "\n")
+        return "updated" if existed else "created"
+
     def _ensure_project_scripts(
         self, pyproject_path: Path, command_name: str, force: bool
     ) -> str:
@@ -449,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"
@@ -476,8 +475,7 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["{root_package}*"]
-
-{config_content}'''
+'''
 
         pyproject_path.write_text(pyproject_content)
 
@@ -595,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)
@@ -669,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)
 
@@ -685,22 +670,10 @@ include = ["{root_package}*"]
         )
 
         scripts_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
             )
@@ -735,7 +708,6 @@ include = ["{root_package}*"]
                 title,
                 description,
                 commands_dir,
-                config_content,
             )
             console.print(
                 f"[{COLOR.SUCCESS}]Created {pyproject_path}[/{COLOR.SUCCESS}]"
@@ -744,6 +716,22 @@ include = ["{root_package}*"]
 
             self._sync_environment(project_root, command_name)
 
+        usecli_config_status = self._write_usecli_config(
+            project_root, config_content, force, commands_path
+        )
+        if usecli_config_status == "created":
+            console.print(
+                f"[{COLOR.SUCCESS}]Created {USECLI_CONFIG_TOML} for runtime config fallback[/{COLOR.SUCCESS}]"
+            )
+        elif usecli_config_status == "updated":
+            console.print(
+                f"[{COLOR.SUCCESS}]Updated {USECLI_CONFIG_TOML} for runtime config fallback[/{COLOR.SUCCESS}]"
+            )
+        elif usecli_config_status == "skipped":
+            console.print(
+                f"[{COLOR.WARNING}]Skipped updating {USECLI_CONFIG_TOML}.[/{COLOR.WARNING}]"
+            )
+
         # Show summary
         summary_command = (
             command_name

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

@@ -21,6 +21,8 @@ else:
     import tomli as tomllib
 
 
+PYPROJECT_TOML = "pyproject.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] = {
@@ -46,51 +48,97 @@ 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 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"
+        pyproject_path = current / PYPROJECT_TOML
         if pyproject_path.exists():
             return current
 
+        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.32/src/usecli/cli/templates/usecli.toml.j2 → usecli-0.1.34/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.34/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.32 → usecli-0.1.34}/src/usecli/shared/config/globals.py

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

{usecli-0.1.32 → usecli-0.1.34}/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,6 +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_CONFIG_TOML
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -57,16 +56,7 @@ def _dedupe_items(items: list[str]) -> list[str]:
 
 
 class ConfigManager:
-    """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.
-    """
+    """Manages useCli configuration from project-level files."""
 
     DEFAULT_CONFIG: dict[str, Any] = {
         "title": "usecli",
@@ -87,6 +77,7 @@ class ConfigManager:
     def __init__(
         self,
         pyproject_path: Path | None = None,
+        usecli_config_path: Path | None = None,
         start_dir: Path | None = None,
     ) -> None:
         """Initialize the configuration manager.
@@ -102,12 +93,21 @@ class ConfigManager:
 
         if pyproject_path is None:
             pyproject_path = self._find_pyproject_toml(start_dir) or (
-                start_dir / "pyproject.toml"
+                start_dir / PYPROJECT_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_config_path: Path = usecli_config_path
         self.start_dir: Path = start_dir
-        self.project_root: Path = find_project_root(start_dir) or start_dir.resolve()
+        detected_root = find_project_root(start_dir)
+        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] = {}
         self._load_config()
@@ -117,16 +117,16 @@ class ConfigManager:
         self._config = self.DEFAULT_CONFIG.copy()
         self._overrides = {}
 
-        if self.pyproject_path.exists():
+        if self.usecli_config_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)
+                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 pyproject.toml: {e}",
-                    config_file=str(self.pyproject_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"))
@@ -151,7 +151,7 @@ class ConfigManager:
         current = start_dir.resolve()
 
         while True:
-            pyproject_path = current / "pyproject.toml"
+            pyproject_path = current / PYPROJECT_TOML
             if pyproject_path.exists():
                 return pyproject_path
 
@@ -162,19 +162,90 @@ class ConfigManager:
 
         return None
 
+    @classmethod
+    def _find_usecli_config(cls, start_dir: Path) -> Path | None:
+        current = start_dir.resolve()
+
+        while True:
+            config_path = current / USECLI_CONFIG_TOML
+            if config_path.exists():
+                return config_path
+
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+
+        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 _load_pyproject_toml(path: Path) -> dict[str, Any]:
-        """Load pyproject.toml and return [tool.usecli] section.
+    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
 
-        Args:
-            path: Path to the pyproject.toml file.
+        candidates = [path for path in root_dir.rglob(USECLI_CONFIG_TOML)]
+        if not candidates:
+            return None
 
-        Returns:
-            Parsed [tool.usecli] content as a dictionary, or empty dict.
-        """
+        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_CONFIG_TOML
+            if candidate.exists():
+                return candidate
+            for child in path.glob(f"*/{USECLI_CONFIG_TOML}"):
+                if child.exists():
+                    return child
+        return None
+
+    @staticmethod
+    def _load_usecli_toml(path: Path) -> dict[str, Any]:
         with open(path, "rb") as f:
             data = tomllib.load(f)
-            return data.get("tool", {}).get("usecli", {})
+
+        tool_section = data.get("tool", {})
+        if isinstance(tool_section, dict) and "usecli" in tool_section:
+            usecli_section = tool_section.get("usecli")
+            if isinstance(usecli_section, dict):
+                return usecli_section
+
+        usecli_section = data.get("usecli", {})
+        if isinstance(usecli_section, dict):
+            return usecli_section
+
+        return {}
 
     def get(self, key: str, default: Any = None) -> Any:
         """Get a configuration value using dot notation.
@@ -255,10 +326,7 @@ class ConfigManager:
 
     @property
     def pyproject_exists(self) -> bool:
-        """Check if pyproject.toml with [tool.usecli] exists."""
-        if not self.pyproject_path.exists():
-            return False
-        return self._pyproject_has_usecli(self.pyproject_path)
+        return self.usecli_config_path.exists()
 
     @staticmethod
     def _load_project_version(path: Path) -> str | None:
@@ -304,18 +372,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"
+        pyproject_path = current / PYPROJECT_TOML
         if pyproject_path.exists():
             return current
 
+        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