usecli 0.1.43__tar.gz → 0.1.45__tar.gz

{usecli-0.1.43 → usecli-0.1.45}/PKG-INFO

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

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

@@ -103,15 +103,21 @@ 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:
+        return any(part in ConfigManager._SKIP_DIRS for part in path.parts)
+
     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(
@@ -707,6 +713,8 @@ include = ["{root_package}*"]
         if commands_path.parent != project_root:
             config_root = commands_path.parent
         existing_config = ConfigManager(start_dir=config_root).usecli_config_path
+        if existing_config.exists() and self._should_skip_config_path(existing_config):
+            existing_config = config_root / USECLI_CONFIG_TOML
         default_config_path = (
             existing_config
             if existing_config.exists()

{usecli-0.1.43 → usecli-0.1.45}/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
@@ -233,9 +234,11 @@ 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():
@@ -247,14 +250,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 +464,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 +483,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.43 → usecli-0.1.45}/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 and title != "usecli":
-        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.43 → usecli-0.1.45}/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