usecli 0.1.45__tar.gz → 0.1.47__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.45"
+version = "0.1.47"
 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.45 → usecli-0.1.47}/src/usecli/cli/commands/defaults/base/about_command.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import importlib.metadata
+import os
 import platform
 import re
 import sys
@@ -55,7 +57,51 @@ def _parse_dependency_requirement(req: str) -> tuple[str, str | None]:
     return name, remainder
 
 
+def _get_console_script_distribution(
+    command_name: str | None,
+) -> importlib.metadata.Distribution | None:
+    if not command_name:
+        return None
+    try:
+        distributions = importlib.metadata.distributions()
+    except Exception:
+        return None
+    for dist in distributions:
+        try:
+            entry_points = dist.entry_points
+        except Exception:
+            continue
+        for entry_point in entry_points:
+            if entry_point.group != "console_scripts":
+                continue
+            if entry_point.name == command_name:
+                return dist
+    return None
+
+
+def _get_package_dependencies_from_distribution(
+    dist: importlib.metadata.Distribution,
+) -> list[tuple[str, str | None]]:
+    requires = dist.requires or []
+    result: list[tuple[str, str | None]] = []
+    for req in requires:
+        if not isinstance(req, str):
+            continue
+        name, spec = _parse_dependency_requirement(req)
+        if name and not req.startswith("("):
+            result.append((name, spec))
+    return result
+
+
 def _get_dependencies(config: ConfigManager) -> list[tuple[str, str | None]]:
+    command_name = os.path.basename(sys.argv[0]) if sys.argv else None
+    dist = _get_console_script_distribution(command_name)
+    if dist is None:
+        primary_command = get_script_command_name(default=None)
+        dist = _get_console_script_distribution(primary_command)
+    if dist is not None:
+        return _get_package_dependencies_from_distribution(dist)
+
     pyproject_path = config.pyproject_path
     if not pyproject_path.exists():
         return []
@@ -79,8 +125,91 @@ def _get_dependencies(config: ConfigManager) -> list[tuple[str, str | None]]:
     return result
 
 
+def _get_application_distribution() -> importlib.metadata.Distribution | None:
+    command_name = os.path.basename(sys.argv[0]) if sys.argv else None
+    dist = _get_console_script_distribution(command_name)
+    if dist is None:
+        primary_command = get_script_command_name(default=None)
+        dist = _get_console_script_distribution(primary_command)
+    return dist
+
+
+def _get_application_version(config: ConfigManager) -> str:
+    dist = _get_application_distribution()
+    if dist is not None:
+        return dist.version
+
+    config_version = config.get_project_version()
+    if config_version:
+        return config_version
+
+    return _get_version()
+
+
+def _get_application_description(config: ConfigManager) -> str:
+    description = config.get("description")
+    if (
+        config.has_key("description")
+        and isinstance(description, str)
+        and description.strip()
+    ):
+        return description.strip()
+
+    project_description = _get_project_description(config)
+    if project_description:
+        return project_description
+
+    return (
+        "An elegant CLI framework for Python with prefix matching, "
+        "rich UI, and command scaffolding."
+    )
+
+
+def _get_project_description(config: ConfigManager) -> str | None:
+    pyproject_path = config.pyproject_path
+    if not pyproject_path.exists():
+        return None
+
+    try:
+        data = tomllib.loads(pyproject_path.read_text())
+    except (tomllib.TOMLDecodeError, OSError):
+        return None
+
+    description = data.get("project", {}).get("description")
+    if isinstance(description, str) and description.strip():
+        return description.strip()
+    return None
+
+
+def _get_installed_script_commands(command_name: str | None) -> list[str]:
+    dist = _get_console_script_distribution(command_name)
+    if dist is None:
+        return []
+    try:
+        entry_points = dist.entry_points
+    except Exception:
+        return []
+    script_names = [
+        entry_point.name
+        for entry_point in entry_points
+        if entry_point.group == "console_scripts"
+    ]
+    if not script_names:
+        return []
+    if command_name and command_name in script_names:
+        return [command_name, *[name for name in script_names if name != command_name]]
+    return script_names
+
+
 def _get_script_commands() -> list[str]:
     primary_command = get_script_command_name(default=None)
+    command_name = os.path.basename(sys.argv[0]) if sys.argv else primary_command
+    installed_commands = _get_installed_script_commands(command_name)
+    if installed_commands:
+        if primary_command and primary_command not in installed_commands:
+            return [primary_command, *installed_commands]
+        return installed_commands
+
     pyproject_path = Path.cwd() / "pyproject.toml"
     if not pyproject_path.exists():
         if primary_command:
@@ -115,19 +244,9 @@ class AboutCommand(BaseCommand):
 
     def handle(self) -> None:
         config = get_config()
-        version = config.get_project_version() or _get_version()
+        version = _get_application_version(config)
         app_name = get_project_name()
-        description = config.get("description")
-        if not (
-            config.has_key("description")
-            and isinstance(description, str)
-            and description.strip()
-        ):
-            description = (
-                "An elegant CLI framework for Python with prefix matching, "
-                "rich UI, and command scaffolding."
-            )
-        description = description.strip() if isinstance(description, str) else ""
+        description = _get_application_description(config)
 
         console.print()
         console.print(f"[bold {COLOR.PRIMARY}]Description[/bold {COLOR.PRIMARY}]")
@@ -138,8 +257,11 @@ class AboutCommand(BaseCommand):
         console.print(f"[bold {COLOR.PRIMARY}]Environment[/bold {COLOR.PRIMARY}]")
         console.print(f"[{COLOR.PRIMARY}]─" * 78)
 
-        self._print_row("Application Name", app_name)
-        self._print_row("Application Version", version)
+        dist = _get_application_distribution()
+        name_label = "Cli Name" if dist is not None else "Application Name"
+        version_label = "Cli Version" if dist is not None else "Application Version"
+        self._print_row(name_label, app_name)
+        self._print_row(version_label, version)
         self._print_row("Python Version", platform.python_version())
         self._print_row("Platform", f"[{COLOR.FOREGROUND_MUTED}]{platform.platform()}")
 
@@ -159,9 +281,6 @@ class AboutCommand(BaseCommand):
         deps = _get_dependencies(config)
         if deps:
             for dep_name, spec in deps:
-                if dep_name == "usecli" and spec:
-                    self._print_row(dep_name, spec)
-                    continue
                 try:
                     installed_version = get_version(dep_name)
                     self._print_row(dep_name, installed_version)

{usecli-0.1.45 → usecli-0.1.47}/src/usecli/cli/commands/init_command.py

@@ -108,7 +108,17 @@ class InitCommand(BaseCommand):
         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)
+        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()
@@ -186,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
@@ -509,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()
@@ -712,14 +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
-        if existing_config.exists() and self._should_skip_config_path(existing_config):
+        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.45 → usecli-0.1.47}/src/usecli/cli/config/colors.py

@@ -100,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:
@@ -242,7 +346,7 @@ def _load_usecli_config(
 
     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,

{usecli-0.1.45 → usecli-0.1.47}/src/usecli/usecli.config.toml

@@ -3,7 +3,7 @@ command_name = "usecli"
 title = "usecli"
 title_file = "cli/core/ui/title.txt"
 title_font = "ansi_shadow"
-description = "A custom CLI tool"
+description = "A powerful Python CLI framework for building beautiful, developer-friendly command-line tools."
 commands_dir = "cli/commands/custom"
 templates_dir = "cli/templates"
 themes_dir = "cli/themes"