strictcli 0.41.0__tar.gz → 0.41.2__tar.gz

{strictcli-0.41.0 → strictcli-0.41.2}/PKG-INFO

@@ -1,16 +1,21 @@
 Metadata-Version: 2.5
 Name: strictcli
-Version: 0.41.0
-Summary: A strict CLI framework for Python
-Project-URL: Homepage, https://github.com/smm-h/strictcli
+Version: 0.41.2
+Summary: A strict CLI framework for Python, Go and TypeScript that makes you declare every command, flag, argument and help string, and errors at registration time on anything left unstated (Python implementation)
+Project-URL: Homepage, https://smmh.dev/strictcli/
+Project-URL: Documentation, https://smmh.dev/strictcli/
 Project-URL: Repository, https://github.com/smm-h/strictcli
+Project-URL: Issues, https://github.com/smm-h/strictcli/issues
+Project-URL: Changelog, https://github.com/smm-h/strictcli/blob/main/CHANGELOG.md
 Author-email: "S. M. Hosseini" <m.hosseini@veliu.com>
 License-Expression: MIT
 License-File: LICENSE
-Keywords: argparse,cli,command-line,framework,rlsbl,strictcli
+Keywords: argparse,argument-parser,cli,cli-framework,command-line,framework,rlsbl,strictcli
 Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
@@ -19,7 +24,7 @@ Description-Content-Type: text/markdown
 
 # strictcli
 
-A strict CLI framework for Python.
+A strict CLI framework for Python, Go and TypeScript that makes you declare every command, flag, argument and help string, and errors at registration time on anything left unstated (Python implementation).
 
 strictcli makes you declare everything -- every command, flag, argument, and environment variable must have help text or the framework errors at registration time. Four types only: `str`, `bool`, `int`, `float`. No magic type inference, no implicit defaults.
 

{strictcli-0.41.0 → strictcli-0.41.2}/README.md

@@ -1,6 +1,6 @@
 # strictcli
 
-A strict CLI framework for Python.
+A strict CLI framework for Python, Go and TypeScript that makes you declare every command, flag, argument and help string, and errors at registration time on anything left unstated (Python implementation).
 
 strictcli makes you declare everything -- every command, flag, argument, and environment variable must have help text or the framework errors at registration time. Four types only: `str`, `bool`, `int`, `float`. No magic type inference, no implicit defaults.
 

{strictcli-0.41.0 → strictcli-0.41.2}/pyproject.toml

@@ -4,17 +4,28 @@ build-backend = "hatchling.build"
 
 [project]
 name = "strictcli"
-version = "0.41.0"
-description = "A strict CLI framework for Python"
+version = "0.41.2"
+description = "A strict CLI framework for Python, Go and TypeScript that makes you declare every command, flag, argument and help string, and errors at registration time on anything left unstated (Python implementation)"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11"
 authors = [{ name = "S. M. Hosseini", email = "m.hosseini@veliu.com" }]
-keywords = ["strictcli", "cli", "argparse", "command-line", "framework", "rlsbl"]
+keywords = [
+    "strictcli",
+    "cli",
+    "cli-framework",
+    "command-line",
+    "argument-parser",
+    "argparse",
+    "framework",
+    "rlsbl",
+]
 classifiers = [
     "Development Status :: 3 - Alpha",
+    "Environment :: Console",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
@@ -29,5 +40,8 @@ dev = ["pytest", "allpairspy", "jsonschema"]
 testpaths = ["tests"]
 
 [project.urls]
-Homepage = "https://github.com/smm-h/strictcli"
+Homepage = "https://smmh.dev/strictcli/"
+Documentation = "https://smmh.dev/strictcli/"
 Repository = "https://github.com/smm-h/strictcli"
+Issues = "https://github.com/smm-h/strictcli/issues"
+Changelog = "https://github.com/smm-h/strictcli/blob/main/CHANGELOG.md"

{strictcli-0.41.0 → strictcli-0.41.2}/strictcli/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.41.0"
+__version__ = "0.41.2"
 
 __all__ = [
     "App", "Flag", "Arg", "FlagSet",
@@ -4606,6 +4606,10 @@ _RECORD_SOURCES_ATTR = "__strictcli_sources__"
 _RECORD_SPELLING = "Choice(<value>, help=...)"
 _SELECTOR_SPELLING = "choice_flag(...)"
 _MEMBER_SELECTOR_SPELLING = 'choice_flag(..., elect_by="member-flags")'
+# The payload-carrying member's own declaration, which is where its short goes:
+# `member_value(...)` IS the electing flag's declaration in this language, the
+# way `MemberChoice`'s first argument is in Go (§24.12).
+_MEMBER_PAYLOAD_SHORT_SPELLING = "member_value(short=...)"
 
 
 @dataclass(frozen=True)
@@ -5129,6 +5133,11 @@ class _ChoiceDecl:
     help: str
     cls: type
     localns: dict
+    # The short of a PAYLOAD-LESS member's electing flag (§24.4, §24.12). A
+    # payload-carrying member declares its short on `member_value(short=...)`
+    # instead -- that field IS its electing flag's declaration -- and a
+    # token-spelled choice has no flag of its own to carry one at all.
+    short: str | None = None
 
 
 @dataclass(frozen=True)
@@ -5140,6 +5149,11 @@ class _ChoiceSpec:
     cls: type
     members: tuple[object, ...]  # Flag | _Selector, in declaration order
     payload: Flag | None = None  # member spelling's `value` field, if any
+    # The member flag's short, whichever spelling declared it: the one place
+    # every reader of a member's short looks (the cross-scope claim table, the
+    # `-x` token scan, the help line). None for a token-spelled choice, which
+    # is never a token of its own.
+    short: str | None = None
 
 
 @dataclass(frozen=True)
@@ -5228,6 +5242,33 @@ def _raise_token_choice_carries_payload(sel: str, c: str):
     )
 
 
+def _raise_token_choice_carries_short(sel: str, c: str):
+    """Authored: a short on a token-spelled choice has no token to name.
+
+    Under token spelling the choice is named by the selector's own value, and
+    a value has no short form -- only a member-spelled choice puts a flag of
+    its own on the command line (§24.4).
+    """
+    raise ValueError(
+        f'Choice "{c}" of "{sel}": a token-spelled choice cannot carry a '
+        f"short: the token names the choice, and only a member-spelled choice "
+        f"has a flag of its own to carry one"
+    )
+
+
+def _raise_member_short_on_payload_choice(sel: str, c: str):
+    """Authored: one member, one place to declare its short (§24.4, §24.12).
+
+    A payload-carrying member's electing flag IS its payload declaration, so
+    the short belongs there; carrying it on the choice as well would be two
+    declarations that must agree.
+    """
+    raise ValueError(
+        f'Choice "{c}" of "{sel}": a payload-carrying member declares its '
+        f"short on its payload: {_MEMBER_PAYLOAD_SHORT_SPELLING}"
+    )
+
+
 def _raise_scoped_name_choice_reserved(c: str, sel: str):
     raise ValueError(
         f'Choice "{c}" of "{sel}": flag name \'choice\' is reserved by the '
@@ -5579,7 +5620,9 @@ def _raise_selector_default_not_instance(sel: str, got: str):
 # --- the declaration surface -----------------------------------------------
 
 
-def choice(name: str, *, help: str):  # noqa: A002 - mirrors the framework keyword
+def choice(  # noqa: A002 - mirrors the framework keyword
+    name: str, *, help: str, short: str | None = None,
+):
     """Class decorator: declare one choice of a selector, and its scope.
 
     The decorated class becomes a **frozen, keyword-only dataclass** -- it is
@@ -5588,6 +5631,12 @@ def choice(name: str, *, help: str):  # noqa: A002 - mirrors the framework keywo
     out of ``dataclasses`` (§24.12). Its fields ARE the scope's flags, declared
     with :func:`sub_flag`, :func:`sub_choice_flag` or :func:`member_value`.
 
+    ``short`` declares the short form of a **payload-less member's** electing
+    flag: such a choice has no ``member_value`` field, so the decorator is the
+    only place its one token is declared. A payload-carrying member declares
+    its short on :func:`member_value` instead, and a token-spelled choice
+    cannot carry one at all -- both are registration errors (§24.4).
+
     Validation of the scope is deferred to the selector that claims this class,
     because every message a scope raises names both the choice and the selector.
     """
@@ -5605,7 +5654,7 @@ def choice(name: str, *, help: str):  # noqa: A002 - mirrors the framework keywo
                 ))
         dc = dataclasses.dataclass(frozen=True, kw_only=True)(cls)
         setattr(dc, _CHOICE_SPEC_ATTR, _ChoiceDecl(
-            name=name, help=help, cls=dc, localns=localns,
+            name=name, help=help, cls=dc, localns=localns, short=short,
         ))
         return dc
 
@@ -5716,14 +5765,21 @@ def _scope_field(payload: dict, default: object):
     return field(default=default, metadata=meta)
 
 
-def member_value(*, help: str):  # noqa: A002
+def member_value(*, help: str, short: str | None = None):  # noqa: A002
     """Declare a member-spelled choice's own payload (§24.4, §24.12).
 
     A payload is exactly one value, delivered under the reserved name ``value``,
     and only under member spelling. It takes no presence keyword, because
     electing the member supplies it.
+
+    ``short`` is the electing flag's short form (``-r X`` for ``--role X``):
+    this field IS that flag's declaration, exactly as ``MemberChoice``'s first
+    argument is in Go. It is claimed across every simultaneously live scope
+    like any other short, and it renders beside the member on its help line.
     """
-    return field(metadata={_SCOPE_FIELD_KEY: {"kind": "payload", "help": help}})
+    return field(metadata={_SCOPE_FIELD_KEY: {
+        "kind": "payload", "help": help, "short": short,
+    }})
 
 
 def choice_flag(
@@ -6053,7 +6109,7 @@ def _build_choice_spec(
                 )
             payload = Flag(
                 name=decl.name, type=hints[f.name], help=meta["help"],
-                presence=_PRESENCE_REQUIRED,
+                presence=_PRESENCE_REQUIRED, short=meta["short"],
             )
             continue
         # The two reserved names, checked before anything else looks at the
@@ -6099,9 +6155,20 @@ def _build_choice_spec(
             )
         members.append(nested)
 
+    # The member's short, resolved to the ONE slot every reader looks at. Which
+    # declaration carries it follows the member's shape: a payload-carrying
+    # member's electing flag is its `member_value(...)`, a payload-less one has
+    # no such field and declares it on `@choice(...)` (§24.4, §24.12).
+    if decl.short is not None:
+        if elect_by != _ELECT_MEMBER_FLAGS:
+            _raise_token_choice_carries_short(sel_name, decl.name)
+        if payload is not None:
+            _raise_member_short_on_payload_choice(sel_name, decl.name)
+    short = decl.short if payload is None else payload.short
+
     return _ChoiceSpec(
         name=decl.name, help=decl.help, cls=cls,
-        members=tuple(members), payload=payload,
+        members=tuple(members), payload=payload, short=short,
     )
 
 
@@ -6238,6 +6305,22 @@ def _member_spelling_map(selectors: tuple[_Selector, ...]) -> dict[str, bool]:
     return out
 
 
+def _short_claim_path(site: _Site) -> tuple[tuple[str, str], ...]:
+    """The scope a site's short is claimed IN.
+
+    For every ordinary declaration that is the site's own path. A member site
+    is recorded at the path its selector sits on -- its NAME is a flag name
+    command-wide (§24.7) -- but the token it puts on the command line exists
+    only while that member is elected, so its short is claimed one segment
+    deeper. Two sibling members therefore never collide; what refuses them is
+    the election-token guard (§18.19 item 221).
+    """
+    if site.kind != "member":
+        return site.path
+    sel: _Selector = site.decl  # type: ignore[assignment]
+    return site.path + ((sel.name, site.choice.name),)
+
+
 def _paths_mutually_exclusive(
     a: tuple[tuple[str, str], ...], b: tuple[tuple[str, str], ...],
 ) -> bool:
@@ -6328,7 +6411,7 @@ def _validate_scoped_names(
     shorts: list[tuple[str, _Site]] = []
     for site in sites:
         if site.kind == "member":
-            short = site.choice.payload.short if site.choice.payload else None
+            short = site.choice.short
         else:
             short = getattr(site.decl, "short", None)
         if short:
@@ -6346,7 +6429,9 @@ def _validate_scoped_names(
             (s1, a), (s2, b) = shorts[i], shorts[j]
             if s1 != s2 or a.name == b.name:
                 continue
-            if _paths_mutually_exclusive(a.path, b.path):
+            if _paths_mutually_exclusive(
+                _short_claim_path(a), _short_claim_path(b),
+            ):
                 continue
             _raise_short_collides_across_scopes(cmd_name, s1, a.name, b.name)
 
@@ -8893,6 +8978,12 @@ class App:
             # recorder and the check provider use these absolute paths so that
             # tests which chdir still record into the repo, and a check evaluated
             # from a foreign cwd reads the app's own repo state.
+            #
+            # Only the PATHS are computed here. The directory itself is created
+            # lazily by _record_coverage, immediately before the first shard
+            # write: shards are written only on the test-harness paths (test()
+            # and call()), so a plain CLI invocation must leave no .strictcli/
+            # behind in whatever directory it was run from.
             self._coverage_dir = os.path.abspath(
                 os.path.join(".strictcli", "coverage")
             )
@@ -8903,7 +8994,6 @@ class App:
                 self._coverage_dir,
                 f"{os.getpid()}.jsonl",
             )
-            os.makedirs(self._coverage_dir, exist_ok=True)
             self.register_check_provider(self._test_coverage_provider)
 
     def _validate_flag_infra_marker(self, f: Flag) -> None:
@@ -14659,7 +14749,10 @@ def _parse_command(
             scoped_occs.append(_Occ(name, inline, tok, alts, seq=idx))
             return idx + 1
         if idx + 1 >= len(tokens):
-            raise _ParseError(f"flag '--{name}' requires a value")
+            # The token AS TYPED, which is what the root-scope path and both
+            # sibling implementations report: a reader who typed `-r` is told
+            # about `-r`, not about the long form it resolved to.
+            raise _ParseError(f"flag '{tok}' requires a value")
         scoped_occs.append(_Occ(name, tokens[idx + 1], tok, alts, seq=idx))
         return idx + 2
 
@@ -15206,10 +15299,7 @@ def _build_and_validate_command(
     scoped_shorts: dict[str, tuple[str, ...]] = {}
     for site in site_list:
         if site.kind == "member":
-            short = (
-                site.choice.payload.short
-                if site.choice.payload is not None else None
-            )
+            short = site.choice.short
         else:
             short = getattr(site.decl, "short", None)
         if not short:
@@ -15849,14 +15939,17 @@ def _build_selector_spec(sel: _Selector) -> str:
 
 
 def _build_member_spec(spec: _ChoiceSpec) -> str:
-    """The left-column spec for one member flag under member spelling."""
+    """The left-column spec for one member flag under member spelling.
+
+    The short comes from the choice rather than from its payload: a
+    payload-less member declares one too, on `@choice(short=...)`.
+    """
     out = f"--{spec.name}"
+    if spec.short:
+        out += f", -{spec.short}"
     payload = spec.payload
-    if payload is not None:
-        if payload.short:
-            out += f", -{payload.short}"
-        if payload.type is not bool:
-            out += f" <{_TYPE_NAMES[payload.type]}>"
+    if payload is not None and payload.type is not bool:
+        out += f" <{_TYPE_NAMES[payload.type]}>"
     return out
 
 

{strictcli-0.41.0 → strictcli-0.41.2}/tests/test_coverage.py

@@ -206,6 +206,7 @@ class TestCoverageCheck:
         when NEITHER a manifest NOR any shards exist."""
         app = _make_app(tmp_path)
         manifest_path = tmp_path / ".strictcli" / "test-coverage.json"
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
         manifest_path.write_text("[]\n")
 
         results, _, code = app.run_checks(
@@ -296,6 +297,7 @@ class TestManifestUnionVerdict:
         with no shard files (the machine never ran the suite)."""
         app = _make_app(tmp_path)
         manifest_path = tmp_path / ".strictcli" / "test-coverage.json"
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
         manifest_path.write_text(
             json.dumps(["build", "deploy", "status"], indent=2) + "\n"
         )
@@ -312,6 +314,7 @@ class TestManifestUnionVerdict:
         (anchored manifest), not the foreign directory."""
         app = _make_app(tmp_path)
         manifest_path = tmp_path / ".strictcli" / "test-coverage.json"
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
         manifest_path.write_text(
             json.dumps(["build", "deploy", "status"], indent=2) + "\n"
         )
@@ -330,6 +333,7 @@ class TestManifestUnionVerdict:
         """A run recording only a subset keeps prior commands covered (union)."""
         app = _make_app(tmp_path)
         manifest_path = tmp_path / ".strictcli" / "test-coverage.json"
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
         manifest_path.write_text(
             json.dumps(["build", "deploy", "status"], indent=2) + "\n"
         )
@@ -374,3 +378,35 @@ class TestCoverageDisabled:
 
         coverage_dir = tmp_path / ".strictcli" / "coverage"
         assert not coverage_dir.exists()
+
+
+class TestCoverageDirectoryIsLazy:
+    def test_construction_leaves_no_directory(self, tmp_path):
+        """Constructing an app with test_coverage=True must not create
+        .strictcli/ -- a plain CLI invocation never records coverage, so it must
+        not plant an empty directory in whatever cwd it was run from."""
+        app = _make_app(tmp_path)
+        assert app is not None
+        assert not (tmp_path / ".strictcli").exists()
+
+    def test_recording_creates_the_directory(self, tmp_path):
+        """The recorder creates the coverage directory immediately before the
+        first shard write."""
+        app = _make_app(tmp_path)
+        app.test(["deploy"])
+
+        shard = tmp_path / ".strictcli" / "coverage" / f"{os.getpid()}.jsonl"
+        assert shard.is_file()
+
+    def test_check_skips_when_directory_absent(self, tmp_path):
+        """The provider reads a coverage root that does not exist without
+        raising -- it reports the subject-matter SKIP."""
+        app = _make_app(tmp_path)
+        assert not (tmp_path / ".strictcli").exists()
+
+        results, _, _code = app.run_checks(
+            SimpleCtx(project_root=tmp_path),
+            run_all=True,
+        )
+        cov_result = next(r for r in results if r.name == "cli-test-coverage")
+        assert cov_result.status == "skip"

{strictcli-0.41.0 → strictcli-0.41.2}/tests/test_member_spelling.py

@@ -686,3 +686,241 @@ def test_a_later_scope_violation_outranks_an_earlier_missing_payload():
         "flag '--strict' is only valid under '--one-tag', but "
         "'--all-tags' was elected"
     )
+
+
+# ---------------------------------------------------------------------------
+# A member's short (§24.4, §24.12)
+#
+# The member flag is the only token member spelling puts on the command line,
+# so its short is an ordinary flag short: claimed across every simultaneously
+# live scope, typed as `-x`, and rendered beside the member on its help line.
+# Which declaration carries it follows the member's shape -- a payload-carrying
+# member's electing flag IS its `member_value(...)`, and a payload-less one has
+# no such field, so it declares the short on `@choice(...)`.
+# ---------------------------------------------------------------------------
+
+
+def _short_app():
+    @choice("role", help="one role")
+    class Role:
+        value: str = member_value(help="the role name", short="r")
+
+    @choice("cont", help="continue the previous session", short="c")
+    class Cont:
+        pass
+
+    @choice("plain", help="a plain session", short="p")
+    class Plain:
+        pass
+
+    app = strictcli.App(name="myapp", version="1.0.0", help="test app")
+
+    @app.command("launch", effect="read_only", help="launch it")
+    @choice_flag(
+        "start", help="how to start", presence="required",
+        elect_by="member-flags", choices=[Role, Cont, Plain],
+    )
+    def launch(ctx, start: Role | Cont | Plain):
+        match start:
+            case Role(value=v):
+                print(f"role={v}")
+            case Cont():
+                print("cont")
+            case Plain():
+                print("plain")
+
+    return app
+
+
+def test_a_payload_carrying_member_elects_by_its_short():
+    r = _short_app().test(["launch", "-r", "admin"])
+    assert r.exit_code == 0
+    assert r.stdout == "role=admin\n"
+
+
+def test_a_payload_carrying_members_short_consumes_the_next_token():
+    """`-r X` is the member's own value, exactly as `--role X` is."""
+    r = _short_app().test(["launch", "-r", "--plain"])
+    assert r.exit_code == 0
+    assert r.stdout == "role=--plain\n"
+
+
+def test_a_payload_less_member_elects_by_its_short():
+    r = _short_app().test(["launch", "-c"])
+    assert r.exit_code == 0
+    assert r.stdout == "cont\n"
+
+
+def test_a_member_short_is_refused_a_value():
+    r = _short_app().test(["launch", "-c", "extra"])
+    assert r.exit_code == 1
+    assert "unexpected argument 'extra'" in r.stderr
+
+
+def test_a_member_with_a_short_is_still_declined_by_the_long_negation():
+    """The short elects; the decline keeps its one spelling (§21.2)."""
+    r = _short_app().test(["launch", "--no-cont"])
+    assert r.exit_code == 1
+    assert (
+        "error: one of --role, --cont, --plain is required "
+        "(--no-cont declines an option; it does not choose one)\n"
+    ) in r.stderr
+
+
+def test_a_decline_beside_a_short_election_names_the_members_long_form():
+    """§21's A4 error, reached through a short: the message never says `-p`."""
+    r = _short_app().test(["launch", "--no-cont", "-p"])
+    assert r.exit_code == 1
+    assert (
+        "error: --no-cont cannot be combined with --plain "
+        "(--no-cont declines an option; it does not choose one)\n"
+    ) in r.stderr
+
+
+def test_two_members_elected_by_short_are_mutually_exclusive():
+    r = _short_app().test(["launch", "-c", "-p"])
+    assert r.exit_code == 1
+    assert "error: --cont and --plain are mutually exclusive\n" in r.stderr
+
+
+def test_a_member_short_renders_beside_the_member_in_help():
+    r = _short_app().test(["launch", "--help"])
+    assert r.exit_code == 0
+    assert "--role, -r <str>" in r.stdout
+    assert "--cont, -c" in r.stdout
+    assert "--plain, -p" in r.stdout
+
+
+def test_a_member_short_is_claimed_against_a_command_flag():
+    @choice("role", help="one role")
+    class Role:
+        value: str = member_value(help="the role name", short="r")
+
+    @choice("plain", help="a plain session")
+    class Plain:
+        pass
+
+    app = strictcli.App(name="myapp", version="1.0.0", help="test app")
+
+    with pytest.raises(ValueError) as exc:
+
+        @app.command("launch", effect="read_only", help="launch it")
+        @strictcli.flag("repo", help="the repo", short="r", presence="optional")
+        @choice_flag(
+            "start", help="how to start", presence="required",
+            elect_by="member-flags", choices=[Role, Plain],
+        )
+        def launch(ctx, start: Role | Plain, repo: str):
+            pass
+
+    assert str(exc.value) == (
+        'command "launch": short \'-r\' is claimed by \'--role\' and '
+        "'--repo', which can be elected at the same time"
+    )
+
+
+def test_two_sibling_members_may_not_share_a_short():
+    """An election token is read before any election has happened (§24.7)."""
+
+    @choice("cont", help="continue", short="c")
+    class Cont:
+        pass
+
+    @choice("clean", help="start clean", short="c")
+    class Clean:
+        pass
+
+    app = strictcli.App(name="myapp", version="1.0.0", help="test app")
+
+    with pytest.raises(ValueError) as exc:
+
+        @app.command("launch", effect="read_only", help="launch it")
+        @choice_flag(
+            "start", help="how to start", presence="required",
+            elect_by="member-flags", choices=[Cont, Clean],
+        )
+        def launch(ctx, start: Cont | Clean):
+            pass
+
+    assert str(exc.value) == (
+        'command "launch": short \'-c\' is reused by sibling scopes and also '
+        "claimed by '--cont', which elects: an election token is read before "
+        "any election has happened, so its short cannot be shared"
+    )
+
+
+def test_a_token_spelled_choice_cannot_carry_a_short():
+    @choice("email", help="by email", short="e")
+    class Email:
+        pass
+
+    @choice("sms", help="by sms")
+    class Sms:
+        pass
+
+    with pytest.raises(ValueError) as exc:
+        choice_flag(
+            "via", help="delivery channel", presence="required",
+            elect_by="selector-token", choices=[Email, Sms],
+        )
+    assert str(exc.value) == (
+        'Choice "email" of "via": a token-spelled choice cannot carry a '
+        "short: the token names the choice, and only a member-spelled choice "
+        "has a flag of its own to carry one"
+    )
+
+
+def test_a_payload_carrying_member_declares_its_short_on_the_payload():
+    @choice("role", help="one role", short="r")
+    class Role:
+        value: str = member_value(help="the role name")
+
+    @choice("plain", help="a plain session")
+    class Plain:
+        pass
+
+    with pytest.raises(ValueError) as exc:
+        choice_flag(
+            "start", help="how to start", presence="required",
+            elect_by="member-flags", choices=[Role, Plain],
+        )
+    assert str(exc.value) == (
+        'Choice "role" of "start": a payload-carrying member declares its '
+        "short on its payload: member_value(short=...)"
+    )
+
+
+def test_a_member_short_is_published_on_the_payload_entry(tmp_path, monkeypatch):
+    """§25.6's `value` entry is an ordinary flag entry, short included."""
+    import json
+
+    (tmp_path / "pyproject.toml").write_text(
+        '[project]\nname = "myapp"\nversion = "1.0.0"\n',
+    )
+    monkeypatch.chdir(tmp_path)
+    r = _short_app().test(["--dump-schema"])
+    assert r.exit_code == 0
+    dumped = json.loads((tmp_path / ".strictcli" / "schema.json").read_text())
+    sel = dumped["commands"]["launch"]["flags"][0]
+    role = sel["choices"][0]
+    assert role["name"] == "role"
+    assert role["flags"][0]["name"] == "value"
+    assert role["flags"][0]["short"] == "r"
+
+
+def test_a_short_with_nothing_after_it_is_named_as_it_was_typed():
+    """The refusal quotes the TOKEN, not the long form it resolved to.
+
+    The root-scope path has always reported the token as typed; the scoped one
+    reported the long name, which made a `-r` at the end of argv produce a
+    message about `--role` in this implementation alone.
+    """
+    r = _short_app().test(["launch", "-r"])
+    assert r.exit_code == 1
+    assert "error: flag '-r' requires a value\n" in r.stderr
+
+
+def test_a_long_member_token_with_nothing_after_it_is_named_in_full():
+    r = _short_app().test(["launch", "--role"])
+    assert r.exit_code == 1
+    assert "error: flag '--role' requires a value\n" in r.stderr

{strictcli-0.41.0 → strictcli-0.41.2}/tests/test_selectors.py

@@ -2164,3 +2164,29 @@ def test_the_machine_boundary_reads_the_same_sentence():
         "flag '--watch' must be passed as --watch or --no-watch "
         "under '--mode watched'"
     )
+
+
+def test_a_scoped_flags_short_with_no_value_is_named_as_it_was_typed():
+    """§24.3: the scoped path quotes the token, as the root path always has."""
+
+    @choice("a", help="mode a")
+    class A:
+        target: str = sub_flag(help="the target", presence="required", short="t")
+
+    @choice("b", help="mode b")
+    class B:
+        pass
+
+    app = strictcli.App(name="myapp", version="1.0.0", help="test app")
+
+    @app.command("run", effect="read_only", help="run it")
+    @choice_flag(
+        "mode", help="the mode", presence="required",
+        elect_by="selector-token", choices=[A, B],
+    )
+    def run(ctx, mode: A | B):
+        print(repr(mode))
+
+    r = app.test(["run", "--mode", "a", "-t"])
+    assert r.exit_code == 1
+    assert "error: flag '-t' requires a value\n" in r.stderr

{strictcli-0.41.0 → strictcli-0.41.2}/uv.lock

@@ -232,7 +232,7 @@ wheels = [
 
 [[package]]
 name = "strictcli"
-version = "0.41.0"
+version = "0.41.2"
 source = { editable = "." }
 dependencies = [
     { name = "tomlkit" },