usecli 0.1.45__tar.gz → 0.1.46__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.45"
+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.45 → usecli-0.1.46}/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.46}/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,