usecli 0.1.44__tar.gz → 0.1.46__tar.gz

{usecli-0.1.44 → usecli-0.1.46}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.44"
+version = "0.1.46"
 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.44 → usecli-0.1.46}/src/usecli/cli/commands/init_command.py

@@ -103,15 +103,31 @@ class InitCommand(BaseCommand):
             if not should_overwrite:
                 return "skipped"
 
+        config_path.parent.mkdir(parents=True, exist_ok=True)
         config_path.write_text(config_content.rstrip() + "\n")
         return "updated" if existed else "created"
 
+    def _should_skip_config_path(self, path: Path) -> bool:
+        try:
+            resolved = path.resolve()
+        except OSError:
+            resolved = path
+        if any(part in ConfigManager._SKIP_DIRS for part in resolved.parts):
+            return True
+        try:
+            resolved.relative_to(Path(sys.prefix).resolve())
+        except ValueError:
+            return False
+        return True
+
     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()
+        if not path.exists() and path.suffix == "":
+            return (path / USECLI_CONFIG_TOML).resolve()
         return path.resolve()
 
     def _ensure_project_scripts(
@@ -180,6 +196,36 @@ class InitCommand(BaseCommand):
 
         return created
 
+    def _find_project_root_for_init(self, start_dir: Path) -> Path:
+        current = start_dir.resolve()
+        git_root: Path | None = None
+        while True:
+            if (current / "pyproject.toml").exists():
+                return current
+            if (current / USECLI_CONFIG_TOML).exists():
+                return current
+            git_dir = current / ".git"
+            if git_dir.exists():
+                git_root = current
+                break
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+        return (git_root or start_dir).resolve()
+
+    def _find_pyproject_path_for_init(self, start_dir: Path) -> Path | None:
+        current = start_dir.resolve()
+        while True:
+            pyproject_path = current / "pyproject.toml"
+            if pyproject_path.exists():
+                return pyproject_path
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+        return None
+
     def _derive_templates_dir(self, commands_dir: str) -> str:
         commands_path = Path(commands_dir)
         parent = commands_path.parent
@@ -503,12 +549,9 @@ include = ["{root_package}*"]
         ),
     ) -> None:
         cwd = Path.cwd()
-        config_manager = ConfigManager(start_dir=cwd)
-        project_root = config_manager.get_project_root()
-        pyproject_path = (
-            config_manager.pyproject_path
-            if config_manager.pyproject_path.exists()
-            else project_root / "pyproject.toml"
+        project_root = self._find_project_root_for_init(cwd)
+        pyproject_path = self._find_pyproject_path_for_init(cwd) or (
+            project_root / "pyproject.toml"
         )
 
         console.print()
@@ -706,12 +749,20 @@ include = ["{root_package}*"]
         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
+        existing_config = ConfigManager._find_usecli_config_in_tree(
+            project_root,
+            config_root,
+            skip_venv=True,
+        )
+        if existing_config is None or self._should_skip_config_path(existing_config):
+            existing_config = config_root / USECLI_CONFIG_TOML
         default_config_path = (
             existing_config
             if existing_config.exists()
             else config_root / USECLI_CONFIG_TOML
         )
+        if self._should_skip_config_path(default_config_path):
+            default_config_path = config_root / USECLI_CONFIG_TOML
         config_location = Prompt.ask(
             f"[bold {COLOR.SECONDARY}]Config file location[/bold {COLOR.SECONDARY}]"
             " (path or directory)",

{usecli-0.1.44 → usecli-0.1.46}/src/usecli/cli/config/colors.py

@@ -15,8 +15,9 @@ import importlib.metadata
 import importlib.util
 import os
 import sys
+import time
 from pathlib import Path
-from typing import Any, Callable, Final, final
+from typing import Any, Callable, Final, Protocol, cast, final
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -99,6 +100,110 @@ def _find_usecli_config_path(
     return selection[0]
 
 
+def _get_command_name() -> str | None:
+    """Get the current command name from sys.argv."""
+    if not sys.argv:
+        return None
+    command = os.path.basename(sys.argv[0])
+    return command if command else None
+
+
+def _get_console_script_aliases(command_name: str | None) -> set[str]:
+    """Get all aliases for a console script from package metadata."""
+    if not command_name:
+        return set()
+    aliases: set[str] = {command_name}
+    try:
+        distributions = importlib.metadata.distributions()
+    except Exception:
+        return aliases
+    for dist in distributions:
+        try:
+            entry_points = dist.entry_points
+        except Exception:
+            continue
+        names = [
+            entry_point.name
+            for entry_point in entry_points
+            if entry_point.group == "console_scripts"
+        ]
+        if command_name in names:
+            aliases.update(names)
+            break
+    return aliases
+
+
+def _config_matches_command(path: Path, command_name: str | None) -> bool:
+    """Check if a config file matches the given command name."""
+    if command_name is None:
+        return True
+    try:
+        data = _load_usecli_config_file(path)
+    except (tomllib.TOMLDecodeError, OSError):
+        return True
+    config_command = data.get("command_name")
+    if not isinstance(config_command, str):
+        return True
+    normalized = config_command.strip()
+    if not normalized:
+        return True
+    if normalized == command_name:
+        return True
+    aliases = _get_console_script_aliases(command_name)
+    return normalized in aliases
+
+
+def _find_usecli_config_path_for_command(
+    root_dir: Path, start_dir: Path, *, skip_venv: bool
+) -> Path | None:
+    """Find usecli config that matches the current command."""
+    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 _SKIP_DIRS for part in path.parts)
+        ]
+    if not candidates:
+        return None
+
+    command_name = _get_command_name()
+
+    # Filter candidates by command_name matching
+    if command_name:
+        candidates = [
+            path for path in candidates if _config_matches_command(path, command_name)
+        ]
+
+    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_usecli_config_in_package() -> Path | None:
     spec = importlib.util.find_spec(_get_package_name())
     if spec is None or not spec.submodule_search_locations:
@@ -233,13 +338,15 @@ def _find_project_root(start_dir: Path | None = None) -> Path | None:
     return git_root
 
 
-def _load_usecli_config(project_root: Path | None) -> dict[str, Any]:
+def _load_usecli_config(
+    project_root: Path | None,
+) -> tuple[dict[str, Any], Path | None]:
     if project_root is None:
-        return {}
+        return {}, None
 
     config_path = project_root / USECLI_CONFIG_TOML
     if not config_path.exists():
-        config_path = _find_usecli_config_path(
+        config_path = _find_usecli_config_path_for_command(
             project_root,
             project_root,
             skip_venv=True,
@@ -247,14 +354,14 @@ def _load_usecli_config(project_root: Path | None) -> dict[str, Any]:
     if not config_path or not config_path.exists():
         console_match = _find_usecli_config_for_console_script()
         if console_match:
-            return _load_usecli_config_file(console_match)
+            return _load_usecli_config_file(console_match), console_match
         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 {}, None
 
-    return _load_usecli_config_file(config_path)
+    return _load_usecli_config_file(config_path), config_path
 
 
 def _load_usecli_config_file(config_path: Path) -> dict[str, Any]:
@@ -461,16 +568,16 @@ def _load_theme_file(theme_path: Path) -> dict[str, Any]:
     return data
 
 
-def _load_theme() -> tuple[dict[str, str], dict[str, str]]:
+def _load_theme() -> tuple[dict[str, str], dict[str, str], str, Path | None]:
     project_root = _find_project_root()
-    config = _load_usecli_config(project_root)
+    config_values, _ = _load_usecli_config(project_root)
 
     theme_name = DEFAULT_THEME_NAME
-    config_theme = config.get("theme")
+    config_theme = config_values.get("theme")
     if isinstance(config_theme, str) and config_theme.strip():
         theme_name = config_theme.strip()
 
-    theme_path = _resolve_theme_path(theme_name, project_root, config)
+    theme_path = _resolve_theme_path(theme_name, project_root, config_values)
     theme_data = _load_theme_file(theme_path) if theme_path else {}
 
     colors = _merge_theme_values(
@@ -480,14 +587,153 @@ def _load_theme() -> tuple[dict[str, str], dict[str, str]]:
     )
     ansi = _build_ansi_palette(colors)
 
-    return colors, ansi
+    return colors, ansi, theme_name, theme_path
+
+
+_THEME_CACHE: dict[str, Any] = {
+    "context": None,
+    "cwd": None,
+    "config_path": None,
+    "config_sig": None,
+    "last_checked": 0.0,
+}
+
+
+def _config_signature(path: Path) -> tuple[Path, int | None, int | None]:
+    try:
+        stat = path.stat()
+    except OSError:
+        return (path.resolve(), None, None)
+    return (path.resolve(), int(stat.st_mtime), int(stat.st_size))
+
+
+def _compute_theme_context() -> tuple[Path | None, Path | None, str, Path | None]:
+    project_root = _find_project_root()
+    config_values, config_path = _load_usecli_config(project_root)
+    theme_name = DEFAULT_THEME_NAME
+    config_theme = config_values.get("theme")
+    if isinstance(config_theme, str) and config_theme.strip():
+        theme_name = config_theme.strip()
+    theme_path = _resolve_theme_path(theme_name, project_root, config_values)
+    return (
+        project_root.resolve() if project_root else None,
+        config_path.resolve() if config_path else None,
+        theme_name,
+        theme_path.resolve() if theme_path else None,
+    )
 
 
-_THEME_COLORS, _THEME_ANSI = _load_theme()
+def _theme_context() -> tuple[Path | None, Path | None, str, Path | None]:
+    now = time.monotonic()
+    cached_context = _THEME_CACHE.get("context")
+    cached_cwd = _THEME_CACHE.get("cwd")
+    cached_sig = _THEME_CACHE.get("config_sig")
+    cached_path = _THEME_CACHE.get("config_path")
+
+    cwd = Path.cwd().resolve()
+    if cached_context is not None and cached_cwd == cwd:
+        if cached_path is None:
+            return cached_context
+        if now - float(_THEME_CACHE.get("last_checked", 0.0)) < 0.25:
+            return cached_context
+        _THEME_CACHE["last_checked"] = now
+        current_sig = _config_signature(cached_path)
+        if current_sig == cached_sig:
+            return cached_context
+
+    context = _compute_theme_context()
+    _THEME_CACHE["context"] = context
+    _THEME_CACHE["cwd"] = cwd
+    config_path = context[1]
+    _THEME_CACHE["config_path"] = config_path
+    _THEME_CACHE["config_sig"] = _config_signature(config_path) if config_path else None
+    _THEME_CACHE["last_checked"] = now
+    return context
+
+
+class _AnsiNamespace(Protocol):
+    PRIMARY: str
+    SECONDARY: str
+    ACCENT: str
+    FOREGROUND: str
+    FOREGROUND_MUTED: str
+    RESET: str
+    RED: str
+    GREEN: str
+    YELLOW: str
+    BLUE: str
+
+
+class _ColorNamespace(Protocol):
+    ANSI: type[_AnsiNamespace]
+
+
+def _apply_theme(
+    color_class: _ColorNamespace, colors: dict[str, str], ansi: dict[str, str]
+) -> None:
+    for key in (
+        "primary",
+        "secondary",
+        "accent",
+        "success",
+        "error",
+        "warning",
+        "info",
+        "foreground",
+        "foreground_muted",
+        "background",
+        "border",
+        "border_focus",
+        "command",
+        "option",
+        "link",
+        "prompt",
+        "panel_primary",
+        "panel_secondary",
+        "panel_accent",
+    ):
+        setattr(color_class, key.upper(), colors[key])
+
+    ansi_class = color_class.ANSI
+    for key in (
+        "primary",
+        "secondary",
+        "accent",
+        "foreground",
+        "foreground_muted",
+        "reset",
+        "red",
+        "green",
+        "yellow",
+        "blue",
+    ):
+        setattr(ansi_class, key.upper(), ansi[key])
+
+
+def _ensure_theme_loaded(color_class: type[Any]) -> None:
+    global _THEME_CONTEXT
+    context = _theme_context()
+    if context == _THEME_CONTEXT:
+        return
+    colors, ansi, _, _ = _load_theme()
+    _THEME_CONTEXT = context
+    _THEME_COLORS.update(colors)
+    _THEME_ANSI.update(ansi)
+    _apply_theme(cast(_ColorNamespace, color_class), _THEME_COLORS, _THEME_ANSI)
+
+
+_THEME_COLORS, _THEME_ANSI, _THEME_NAME, _THEME_PATH = _load_theme()
+_THEME_CONTEXT: tuple[Path | None, Path | None, str, Path | None] = _theme_context()
+
+
+class _ColorMeta(type):
+    def __getattribute__(cls, name: str) -> Any:
+        _ensure_theme_loaded(cls)
+        return super().__getattribute__(name)
 
 
 @final
-class COLOR:
+class COLOR(metaclass=_ColorMeta):
     """Semantic color system for usecli CLI.
 
     All colors are defined as hex color codes compatible with Rich console.

{usecli-0.1.44 → usecli-0.1.46}/src/usecli/cli/core/ui/title.py

@@ -68,8 +68,9 @@ def get_project_name() -> str:
     # First, try to get the title from the config
     config = get_config()
     title = config.get("title")
-    if title:
-        return title
+    if config.has_key("title") and isinstance(title, str) and title.strip():
+        normalized = title.strip()
+        return "useCli" if normalized == "usecli" else normalized
 
     # Fall back to command name from pyproject.toml scripts
     command_name = _get_script_command_name(Path.cwd())

{usecli-0.1.44 → usecli-0.1.46}/src/usecli/shared/config/manager.py

@@ -582,8 +582,15 @@ _config_manager: ConfigManager | None = None
 def get_config() -> ConfigManager:
     """Get the global ConfigManager instance."""
     global _config_manager
+    current_root = find_project_root(Path.cwd())
+    if current_root is None:
+        current_root = Path.cwd().resolve()
     if _config_manager is None:
-        _config_manager = ConfigManager()
+        _config_manager = ConfigManager(start_dir=Path.cwd())
+    else:
+        cached_root = _config_manager.project_root.resolve()
+        if cached_root != current_root.resolve():
+            _config_manager = ConfigManager(start_dir=Path.cwd())
     return _config_manager