feat(argument): add support for Literal types in Argument

- Automatically set choices from Literal type unless explicitly provided
- Update tests to cover new functionality
- Improve error handling for duplicate command names
- Refactor command inheritance to properly handle __commands__ attribute

Author: Ovizro

src/ptcmd/__init__.py

@@ -37,7 +37,7 @@ def do_hello(
 from .command import Command, auto_argument
 from .info import set_info
 from .core import BaseCmd, Cmd
-from .version import __version__
+from .version import __version__  # noqa: F401
 
 __all__ = [
     "Arg",

src/ptcmd/argument.py

@@ -118,6 +118,9 @@ def __class_getitem__(cls, args: Any) -> Annotated:
         This enables the Argument class to be used in type annotations to define
         command-line arguments in a declarative way.
 
+        Additionally, if the type is a `Literal`, the choices will be automatically
+        set to the values in the Literal, unless the `choices` keyword is explicitly provided.
+
         :param args: Either:
             - A single type (e.g. `Argument[str]`)
             - A tuple of (type, *names, Argument) (e.g. `Argument[str, "-f", "--file"]`)
@@ -147,6 +150,14 @@ def __class_getitem__(cls, args: Any) -> Annotated:
         else:
             kwargs = {}
 
+        # Automatically set choices from Literal type
+        origin = get_origin(tp)
+        if origin is Literal:
+            literal_choices = get_args(tp)
+            # Only set choices if not explicitly provided
+            if "choices" not in kwargs:
+                kwargs["choices"] = literal_choices
+
         if not all(isinstance(arg, str) for arg in args):  # pragma: no cover
             raise TypeError("argument name must be str")
         return Annotated[tp, cls(*args, **kwargs)]  # type: ignore

src/ptcmd/core.py

@@ -180,7 +180,10 @@ def __init__(
         self.cmdqueue = []
         self.lastcmd = ""
         self.command_info  = {}
-        self.command_info = {info.name: info for info in map(self._build_command_info, self.__commands__)}
+        for info in map(self._build_command_info, self.__commands__):
+            if info.name in self.command_info:
+                raise ValueError(f"Duplicate command name: {info.name}")
+            self.command_info[info.name] = info
 
     def cmdloop(self, intro: Optional[Any] = None) -> None:
         """Start the command loop for synchronous execution.
@@ -478,7 +481,10 @@ def __init_subclass__(cls, **kwds: Any) -> None:
             )
             cls.__commands__ = set()
         else:
-            cls.__commands__ = cls.__commands__.copy()
+            cls.__commands__ = set()
+            for base in cls.__bases__:
+                if issubclass(base, BaseCmd):
+                    cls.__commands__.update(base.__commands__)
         for name in dir(cls):
             if not name.startswith(cls.COMMAND_FUNC_PREFIX):
                 continue

tests/test_argument.py

@@ -1,5 +1,6 @@
 import argparse
 from pathlib import Path
+from typing import Literal
 
 import pytest
 from typing_extensions import Annotated
@@ -75,3 +76,31 @@ def test_func(*args: str, verbose: bool) -> dict:
 
     result = invoke_from_argv(test_func, ["--verbose", "arg1", "arg2"], unannotated_mode="autoconvert")
     assert result == {"args": ("arg1", "arg2"), "verbose": True}
+
+
+def test_literal_support() -> None:
+    """Test automatic choices extraction from Literal types."""
+    # Test with Literal type alone
+    arg = Arg[Literal["a", "b", "c"]]
+    arg_ins = get_argument(arg)
+    assert arg_ins is not None
+    assert arg_ins.kwargs.get("choices") == ("a", "b", "c")
+
+    # Test with Literal and flags
+    arg = Arg[Literal[0, 1, 2], "-v", "--verbose"]
+    arg_ins = get_argument(arg)
+    assert arg_ins is not None
+    assert arg_ins.args == ("-v", "--verbose")
+    assert arg_ins.kwargs.get("choices") == (0, 1, 2)
+
+    # Test with explicit choices that override Literal
+    arg = Arg[Literal["x", "y", "z"], "--choice", {"choices": ["x", "y"]}]
+    arg_ins = get_argument(arg)
+    assert arg_ins is not None
+    assert arg_ins.kwargs.get("choices") == ["x", "y"]
+
+    # Test with non-Literal type
+    arg = Arg[str, "--name"]
+    arg_ins = get_argument(arg)
+    assert arg_ins is not None
+    assert "choices" not in arg_ins.kwargs