usecli 0.1.31__tar.gz → 0.1.32__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.31"
+version = "0.1.32"
 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.31 → usecli-0.1.32}/src/usecli/__init__.py

@@ -91,6 +91,20 @@ def _get_cli_help_text() -> str:
     return f"{display_name} - {display_description}"
 
 
+def _get_group_alias_registry(app: typer.Typer) -> dict[str, list[str]]:
+    registry = getattr(app, "_usecli_group_aliases", {})
+    return registry if isinstance(registry, dict) else {}
+
+
+def _build_alias_to_primary(alias_registry: dict[str, list[str]]) -> dict[str, str]:
+    alias_to_primary: dict[str, str] = {}
+    for primary, aliases in alias_registry.items():
+        alias_to_primary[primary] = primary
+        for alias in aliases:
+            alias_to_primary[alias] = primary
+    return alias_to_primary
+
+
 class PrefixMatchingGroup(TyperGroup):
     """Custom Typer group that supports prefix matching for commands.
 
@@ -111,12 +125,33 @@ class PrefixMatchingGroup(TyperGroup):
         if rv is not None:
             return rv
 
+        group_alias_registry = _get_group_alias_registry(app)
+        group_alias_to_primary = _build_alias_to_primary(group_alias_registry)
+
+        if (
+            cmd_name in group_alias_to_primary
+            and group_alias_to_primary[cmd_name] != cmd_name
+        ):
+            return TyperGroup.get_command(self, ctx, group_alias_to_primary[cmd_name])
+
         matches = [x for x in self.list_commands(ctx) if x.startswith(cmd_name)]
+        group_aliases = [
+            alias for aliases in group_alias_registry.values() for alias in aliases
+        ]
+        matches.extend([alias for alias in group_aliases if alias.startswith(cmd_name)])
+        matches = list(dict.fromkeys(matches))
 
         if not matches:
             return None
 
         if cmd_name in matches:
+            if (
+                cmd_name in group_alias_to_primary
+                and group_alias_to_primary[cmd_name] != cmd_name
+            ):
+                return TyperGroup.get_command(
+                    self, ctx, group_alias_to_primary[cmd_name]
+                )
             return TyperGroup.get_command(self, ctx, cmd_name)
 
         return FilteredListCommand(cmd_name)

{usecli-0.1.31 → usecli-0.1.32}/src/usecli/cli/commands/defaults/base/internal/fzf_command.py

@@ -155,11 +155,27 @@ def _run_fzf_menu(
         )
 
 
-def _get_group_subcommands(group_name: str) -> list[dict[str, Any]]:
+def _resolve_group_alias(app: typer.Typer, group_name: str) -> str:
+    registry = getattr(app, "_usecli_group_aliases", {})
+    if not isinstance(registry, dict):
+        return group_name
+    for primary, aliases in registry.items():
+        if group_name == primary:
+            return primary
+        if group_name in aliases:
+            return primary
+    return group_name
+
+
+def _get_group_subcommands(
+    app: typer.Typer,
+    group_name: str,
+) -> list[dict[str, Any]]:
     from usecli.cli.core.base_command import NestedCommandRegistry
 
     registry = NestedCommandRegistry()
-    group_app = registry._groups.get(group_name)
+    resolved_group = _resolve_group_alias(app, group_name)
+    group_app = registry._groups.get(resolved_group)
 
     if not group_app:
         return []
@@ -260,12 +276,19 @@ def run_interactive(
         selected_cmd = next(
             (c for c in ordered_commands if c["name"] == cmd_name), None
         )
+        if not selected_cmd:
+            resolved_group = _resolve_group_alias(app, cmd_name)
+            if resolved_group != cmd_name:
+                cmd_name = resolved_group
+                selected_cmd = next(
+                    (c for c in ordered_commands if c["name"] == cmd_name), None
+                )
         if not selected_cmd:
             ErrorHandler.display_error(f"Unknown command '{cmd_name}'")
             raise typer.Exit(code=1)
 
     if selected_cmd and selected_cmd.get("is_group"):
-        subcommands = _get_group_subcommands(cmd_name)
+        subcommands = _get_group_subcommands(app, cmd_name)
         if not subcommands:
             ErrorHandler.display_error(f"No subcommands found for '{cmd_name}'")
             raise typer.Exit(code=1)

{usecli-0.1.31 → usecli-0.1.32}/src/usecli/cli/core/base_command.py

@@ -344,7 +344,7 @@ class BaseCommand(ABC):
             registry = NestedCommandRegistry()
             group_app = registry.get_or_create_group(self.app, group_name)
 
-            normalized_aliases = self._normalize_aliases(
+            normalized_aliases, group_aliases = self._normalize_nested_aliases(
                 primary_name=command_name,
                 aliases=aliases,
                 group_name=group_name,
@@ -355,6 +355,11 @@ class BaseCommand(ABC):
                 description=self.description(),
                 aliases=normalized_aliases,
             )
+            self._register_group_aliases(
+                app=self.app,
+                group_name=group_name,
+                aliases=group_aliases,
+            )
         else:
             # Single-level command (e.g., "help", "init", "config:set", "make:command")
             name = signature_parts[0]
@@ -409,6 +414,31 @@ class BaseCommand(ABC):
             setattr(app, "_usecli_aliases", registry)
         return registry
 
+    def _get_group_alias_registry(self, app: typer.Typer) -> dict[str, list[str]]:
+        if not hasattr(app, "_usecli_group_aliases"):
+            setattr(app, "_usecli_group_aliases", {})
+        registry = getattr(app, "_usecli_group_aliases")
+        if not isinstance(registry, dict):
+            registry = {}
+            setattr(app, "_usecli_group_aliases", registry)
+        return registry
+
+    def _register_group_aliases(
+        self,
+        app: typer.Typer,
+        group_name: str,
+        aliases: list[str],
+    ) -> None:
+        if not aliases:
+            return
+
+        registry = self._get_group_alias_registry(app)
+        registry.setdefault(group_name, [])
+        for alias in aliases:
+            if alias == group_name or alias in registry[group_name]:
+                continue
+            registry[group_name].append(alias)
+
     def _normalize_aliases(
         self,
         primary_name: str,
@@ -437,6 +467,51 @@ class BaseCommand(ABC):
             normalized.append(alias_name)
         return normalized
 
+    def _normalize_nested_aliases(
+        self,
+        primary_name: str,
+        aliases: list[str],
+        group_name: str,
+    ) -> tuple[list[str], list[str]]:
+        normalized: list[str] = []
+        group_aliases: list[str] = []
+
+        for alias in aliases:
+            alias_parts = alias.split()
+            if len(alias_parts) == 1:
+                alias_name = alias_parts[0]
+                if not self._is_valid_subcommand_name(alias_name):
+                    continue
+                if alias_name == primary_name or alias_name in normalized:
+                    continue
+                normalized.append(alias_name)
+                continue
+
+            if len(alias_parts) != 2:
+                continue
+
+            group_alias, alias_name = alias_parts
+
+            if not self._is_valid_subcommand_name(group_alias):
+                continue
+            if not self._is_valid_subcommand_name(alias_name):
+                continue
+
+            if group_alias == group_name:
+                if alias_name == primary_name or alias_name in normalized:
+                    continue
+                normalized.append(alias_name)
+                continue
+
+            if group_alias not in group_aliases:
+                group_aliases.append(group_alias)
+
+            if alias_name == primary_name or alias_name in normalized:
+                continue
+            normalized.append(alias_name)
+
+        return normalized, group_aliases
+
     def _is_valid_subcommand_name(self, name: str) -> bool:
         """Check if a string is a valid subcommand name (not an argument placeholder).
 

{usecli-0.1.31 → usecli-0.1.32}/src/usecli/cli/core/ui/list.py

@@ -52,6 +52,8 @@ def list_commands(app: typer.Typer, prefix_filter: str | None = None) -> None:
 
     alias_registry = _get_alias_registry(app)
     alias_to_primary = _build_alias_to_primary(alias_registry)
+    group_alias_registry = _get_group_alias_registry(app)
+    group_alias_to_primary = _build_alias_to_primary(group_alias_registry)
 
     command_name = get_script_command_name(default="usecli")
 
@@ -84,23 +86,15 @@ def list_commands(app: typer.Typer, prefix_filter: str | None = None) -> None:
         commands.append(command_entry)
     commands.sort(key=lambda x: x["name"])
 
-    if prefix_filter:
-        filtered = [
-            c
-            for c in commands
-            if c["name"].startswith(prefix_filter)
-            or any(alias.startswith(prefix_filter) for alias in c["aliases"])
-        ]
-        if not filtered:
-            console.print(f"  [dim]No commands found for '{prefix_filter}'[/dim]")
-            console.print()
-            return
-        commands = filtered
-
     groups: dict[str, str] = {}
     if isinstance(click_group, click.Group):
         for cmd_name, cmd_obj in click_group.commands.items():
             if isinstance(cmd_obj, click.Group):
+                if (
+                    cmd_name in group_alias_to_primary
+                    and group_alias_to_primary[cmd_name] != cmd_name
+                ):
+                    continue
                 groups[cmd_name] = (
                     getattr(cmd_obj, "help", f"Commands for {cmd_name}")
                     or f"Commands for {cmd_name}"
@@ -117,7 +111,41 @@ def list_commands(app: typer.Typer, prefix_filter: str | None = None) -> None:
 
     help_flags = "--help, -h"
     all_option_flags = [help_flags] + option_flags
-    all_display_names = [cmd["display_name"] for cmd in commands] + list(groups.keys())
+    group_entries: list[CommandEntry] = []
+    for group_name, group_help in groups.items():
+        aliases = group_alias_registry.get(group_name, list[str]())
+        group_entries.append(
+            {
+                "name": group_name,
+                "display_name": _format_display_name(group_name, aliases),
+                "help": group_help,
+                "aliases": aliases,
+            }
+        )
+
+    if prefix_filter:
+        filtered = [
+            c
+            for c in commands
+            if c["name"].startswith(prefix_filter)
+            or any(alias.startswith(prefix_filter) for alias in c["aliases"])
+        ]
+        filtered_groups = [
+            g
+            for g in group_entries
+            if g["name"].startswith(prefix_filter)
+            or any(alias.startswith(prefix_filter) for alias in g["aliases"])
+        ]
+        if not filtered and not filtered_groups:
+            console.print(f"  [dim]No commands found for '{prefix_filter}'[/dim]")
+            console.print()
+            return
+        commands = filtered
+        group_entries = filtered_groups
+
+    all_display_names = [cmd["display_name"] for cmd in commands] + [
+        entry["display_name"] for entry in group_entries
+    ]
     all_labels = all_display_names + all_option_flags
     longest_label_length = max((len(label) for label in all_labels), default=0)
 
@@ -147,8 +175,9 @@ def list_commands(app: typer.Typer, prefix_filter: str | None = None) -> None:
     if not prefix_filter:
         console.print(f"[bold {COLOR.SECONDARY}]Available commands:")
 
+    group_names = set(groups.keys())
     top_level: list[CommandEntry] = [
-        c for c in commands if ":" not in c["name"] and c["name"] not in groups
+        c for c in commands if ":" not in c["name"] and c["name"] not in group_names
     ]
     with_colon: list[CommandEntry] = [c for c in commands if ":" in c["name"]]
 
@@ -160,15 +189,7 @@ def list_commands(app: typer.Typer, prefix_filter: str | None = None) -> None:
             f"  [{COLOR.COMMAND} not bold]{display_name}[/{COLOR.COMMAND} not bold]{padding}{cmd['help']}"
         )
 
-    for group_name, group_help in groups.items():
-        top_level.append(
-            {
-                "name": group_name,
-                "display_name": group_name,
-                "help": group_help,
-                "aliases": [],
-            }
-        )
+    top_level.extend(group_entries)
 
     top_level.sort(key=lambda x: x["name"])
 
@@ -291,6 +312,11 @@ def _get_alias_registry(app: typer.Typer) -> dict[str, list[str]]:
     return registry if isinstance(registry, dict) else {}
 
 
+def _get_group_alias_registry(app: typer.Typer) -> dict[str, list[str]]:
+    registry = getattr(app, "_usecli_group_aliases", {})
+    return registry if isinstance(registry, dict) else {}
+
+
 def _get_option_description(param: click.Parameter) -> str:
     if "--show-completion" in param.opts:
         return "Show completion for the current shell."

{usecli-0.1.31 → usecli-0.1.32}/src/usecli/cli/templates/command.py.j2

@@ -12,8 +12,8 @@ class {{ class_name }}(BaseCommand):
     def description(self) -> str:
         return "Description for {{ command_name }} command"
 
-    def aliases(self) -> list[str]:
-        return [{{ command_name[:3] }}]
+    # def aliases(self) -> list[str]:
+    #    return [{{ command_name[:3] }}]
 
     def handle(
         self,