strictcli 0.35.2__tar.gz → 0.35.4__tar.gz

{strictcli-0.35.2 → strictcli-0.35.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strictcli
-Version: 0.35.2
+Version: 0.35.4
 Summary: A strict CLI framework for Python
 Project-URL: Homepage, https://github.com/smm-h/strictcli
 Project-URL: Repository, https://github.com/smm-h/strictcli

{strictcli-0.35.2 → strictcli-0.35.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "strictcli"
-version = "0.35.2"
+version = "0.35.4"
 description = "A strict CLI framework for Python"
 readme = "README.md"
 license = "MIT"

{strictcli-0.35.2 → strictcli-0.35.4}/strictcli/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.35.2"
+__version__ = "0.35.4"
 
 __all__ = [
     "App", "Flag", "Arg", "FlagSet", "MutexGroup", "CoRequired", "Requires",
@@ -674,6 +674,16 @@ def _msg_dry_run_truncated(step: int, cmd: str, brand: str) -> str:
     )
 
 
+def _msg_dry_run_aborted(step: int, cmd: str) -> str:
+    """The aborted-preview marker. Same shape and prefix as the truncation
+    error above: both say the preview ended before the handler finished, and
+    they differ only in why and in what the reader may conclude."""
+    return (
+        f"error: dry-run preview ends at step {step}: {cmd} aborted — "
+        f"the preview above may be incomplete"
+    )
+
+
 def _msg_confirm_prompt(cmd_path: str) -> str:
     """The confirm prompt. A prompt, not an error, but parity is still checked."""
     return f"about to run mutating command '{cmd_path}'. Proceed? [y/N] "
@@ -5508,6 +5518,29 @@ class App:
         """Start a new dispatch: reset the structured effect log."""
         self._effect_log = _EffectLog()
 
+    def _render_dry_log(self, cmd_path: str, *, aborted: bool) -> None:
+        """Write the would-do log for a dry run. No-op outside dry mode.
+
+        Called on every exit path out of a dispatch, so a handler that leaves
+        through ``sys.exit`` or an exception still shows the preview it was
+        asked for. The log always goes to stdout and is never suppressed by
+        ``--quiet``: it is dry mode's primary output.
+
+        ``aborted`` marks a dispatch that did not finish. The log is still
+        written -- the recorded effects are owed either way -- and the marker
+        that follows it on stderr says the reader cannot assume the list is
+        the whole preview. The truncation path (which ends the preview for its
+        own pinned reason) renders itself and never comes through here.
+        """
+        if not self._last_dry_run:
+            return
+        print(self._effect_log.render())
+        if aborted:
+            print(
+                _msg_dry_run_aborted(self._effect_log.next_seq(), cmd_path),
+                file=sys.stderr,
+            )
+
     def _record_cache_write(self, path: str) -> None:
         """Record a framework-blessed CACHE_WRITE.
 
@@ -6004,17 +6037,20 @@ class App:
         self._groups["config"] = config_grp
 
     def _pre_scan_reserved_flags(self, argv: list[str]) -> dict:
-        """Position-aware pre-scan for the framework-owned reserved flags.
+        """Pre-scan for the framework-owned reserved flags.
 
         Handles --dump-schema, --mcp, --config, --hermetic and the effects-regime
         quartet --dry-run/--yes/--quiet/--verbose.
 
-        Scans the pre-command region of argv (before the first non-flag
-        token, before ``--``).  Known global flags and their values are
-        skipped so that a global-flag value matching a command name does
-        not terminate the scan early. Everything at or after the command token
-        is left untouched -- which is what keeps a passthrough command's args
-        opaque to the framework.
+        Two regions, two rulesets (contract §7.2, amended):
+
+        - The **pre-command region** (before the first non-flag token, before
+          ``--``) recognizes every reserved flag. Known global flags and their
+          values are skipped so that a global-flag value matching a command name
+          does not terminate the region early.
+        - The **command region** recognizes ONLY the quartet, anywhere, exactly
+          like --help/-h. --hermetic/--config/--dump-schema/--mcp stay
+          pre-command-only. See _scan_command_region_quartet.
 
         Returns a dict with keys: dump_schema, serve_mcp, hermetic, config_path,
         dry_run, yes, quiet, verbose, err, cleaned_argv.
@@ -6030,16 +6066,20 @@ class App:
 
         result: dict = {}
         exclude_indices: set[int] = set()
+        # Index where the command region begins; -1 means "never reached one"
+        # (a bare -- or an unknown flag-like token ended the scan for good).
+        command_region_from = -1
         i = 0
         while i < len(argv):
             tok = argv[i]
 
-            # -- terminates the pre-command region
+            # -- terminates the whole scan: everything after it is data
             if tok == "--":
                 break
 
-            # Non-flag token = command name: stop scanning
+            # Non-flag token = the command token: the command region starts here
             if not tok.startswith("-") or tok == "-":
+                command_region_from = i
                 break
 
             # --dump-schema
@@ -6120,6 +6160,11 @@ class App:
             # Unknown flag-like token: stop
             break
 
+        if command_region_from >= 0:
+            self._scan_command_region_quartet(
+                argv, command_region_from, result, exclude_indices,
+            )
+
         if exclude_indices:
             result["cleaned_argv"] = [
                 tok for j, tok in enumerate(argv) if j not in exclude_indices
@@ -6129,6 +6174,66 @@ class App:
 
         return result
 
+    def _scan_command_region_quartet(
+        self,
+        argv: list[str],
+        start: int,
+        result: dict,
+        exclude_indices: set[int],
+    ) -> None:
+        """Recognize the reserved quartet in the command region of argv.
+
+        Contract §7.2 (amended 2026-08-04): --dry-run/--yes/--quiet/--verbose are
+        recognized ANYWHERE in argv, exactly like --help/-h, because their
+        applicability is per-command -- requiring them before the command name
+        was backwards. Only the quartet is recognized here; --hermetic,
+        --config, --dump-schema and --mcp remain pre-command-only.
+
+        The scan stops for good at two boundaries:
+
+        - a bare ``--``, after which every token is positional data;
+        - a **passthrough** command's name, after which every token belongs to
+          the child process and is forwarded byte-for-byte. Eating a child's own
+          --verbose would silently change what the child does.
+
+        Routing tokens are walked through the group/command tree so a quartet
+        token may sit anywhere among them. Nothing here raises: routing errors
+        are the real parse's job.
+        """
+        groups = self._groups
+        commands = self._commands
+        routing_done = False
+        i = start
+        while i < len(argv):
+            tok = argv[i]
+
+            if tok == "--":
+                return
+
+            if tok.startswith("-") and tok != "-":
+                if tok in _RESERVED_QUARTET_TOKENS:
+                    result[_RESERVED_QUARTET_TOKENS[tok]] = True
+                    exclude_indices.add(i)
+                i += 1
+                continue
+
+            # A non-flag token: a routing token until routing resolves.
+            if not routing_done:
+                grp = groups.get(tok)
+                if grp is not None:
+                    groups = grp._groups
+                    commands = grp.commands
+                    i += 1
+                    continue
+                cmd = commands.get(tok)
+                if cmd is not None and cmd.passthrough is not None:
+                    return
+                # Resolved a normal command, or hit an unknown/deprecated token
+                # the real parse will report: routing is over either way.
+                routing_done = True
+
+            i += 1
+
     def _parse(self, argv: list[str]) -> tuple[Command, dict[str, object] | list[str], dict[str, str]]:
         """Parse argv (without program name) into a resolved Command and kwargs.
 
@@ -6801,20 +6906,31 @@ class App:
             )
             # The confirm protocol fires only on the real CLI path.
             self._confirm_mutating(cmd, cmd_path)
+            # The would-do log renders on EVERY exit path out of the dispatch,
+            # not just the normal return: the operator asked for a preview and
+            # the effects were recorded, so a handler that unwinds through
+            # sys.exit or an exception still owes them the list. The clause set
+            # below is exhaustive by construction -- BaseException is the root
+            # of the hierarchy, so no unwind can slip past it.
             try:
                 if cmd.passthrough is not None:
                     result = cmd.passthrough.handler(ctx, cmd.name, data, self._last_global_values)
                 else:
                     result = cmd.handler(ctx, **data)
+                exit_code, out_data = _interpret_handler_return(result)
+                if out_data is not _MISSING:
+                    print(json.dumps(out_data, default=str, separators=(",", ":")))
             except _DryRunTruncated as trunc:
                 print(trunc.log.render())
                 print(trunc.message, file=sys.stderr)
                 sys.exit(1)
-            exit_code, out_data = _interpret_handler_return(result)
-            if out_data is not _MISSING:
-                print(json.dumps(out_data, default=str, separators=(",", ":")))
-            if self._last_dry_run:
-                print(self._effect_log.render())
+            except SystemExit:
+                self._render_dry_log(cmd_path, aborted=False)
+                raise
+            except BaseException:
+                self._render_dry_log(cmd_path, aborted=True)
+                raise
+            self._render_dry_log(cmd_path, aborted=False)
             sys.exit(exit_code)
 
     def test(self, argv: list[str]) -> Result:
@@ -6873,9 +6989,9 @@ class App:
             exit_code = 1
         else:
             self._begin_dispatch()
+            cmd_path = ".".join(self._last_resolved_path + [cmd.name])
             # Record test-coverage hit (command-level only).
             if self.test_coverage:
-                cmd_path = ".".join(self._last_resolved_path + [cmd.name])
                 self._record_coverage(cmd_path)
             # Store sources for function handlers that need provenance info
             self._last_sources = sources
@@ -6887,9 +7003,7 @@ class App:
                         dry_run=self._last_dry_run, yes=self._last_yes,
                         quiet=self._last_quiet, verbose=self._last_verbose,
                         effects=self._arm_effects(
-                            cmd,
-                            ".".join(self._last_resolved_path + [cmd.name]),
-                            dry_run=self._last_dry_run,
+                            cmd, cmd_path, dry_run=self._last_dry_run,
                         ),
                     )
                     if cmd.passthrough is not None:
@@ -6902,14 +7016,17 @@ class App:
                     if out_data is not _MISSING:
                         result_data = out_data
                         print(json.dumps(out_data, default=str, separators=(",", ":")))
-                    if self._last_dry_run:
-                        print(self._effect_log.render())
+                    self._render_dry_log(cmd_path, aborted=False)
                 except _DryRunTruncated as trunc:
                     print(trunc.log.render())
                     print(trunc.message, file=sys.stderr)
                     exit_code = 1
                 except SystemExit as e:
                     exit_code = e.code if isinstance(e.code, int) else (1 if e.code else 0)
+                    self._render_dry_log(cmd_path, aborted=False)
+                except BaseException:
+                    self._render_dry_log(cmd_path, aborted=True)
+                    raise
 
         return Result(
             stdout=stdout_buf.getvalue(),

{strictcli-0.35.2 → strictcli-0.35.4}/tests/test_effects.py

@@ -203,6 +203,187 @@ class TestWouldDoLog:
         assert (tmp_path / "build").is_dir()
 
 
+_EXPECTED_LOG = (
+    "DRY RUN — no changes were made. Would do:\n"
+    "  1. write: report.txt (2 bytes)\n"
+)
+
+
+class TestWouldDoLogOnEveryExitPath:
+    """The log renders on every exit path out of a dispatch, not just the
+    normal return: `sys.exit`, an uncaught exception, and a bad handler
+    return all still show the preview the operator asked for."""
+
+    @staticmethod
+    def _app_with(handler_tail):
+        app = _app()
+
+        @app.command("rel", help="rel", effect="mutating")
+        def _rel(ctx):
+            ctx.effects.write("report.txt", "ok")
+            return handler_tail()
+
+        return app
+
+    def test_sys_exit_still_renders_the_log(self):
+        app = self._app_with(lambda: sys.exit(1))
+        r = app.test(["--dry-run", "rel"])
+        assert r.exit_code == 1
+        assert r.stdout == _EXPECTED_LOG
+        assert r.stderr == ""
+
+    def test_sys_exit_renders_the_same_bytes_as_an_equivalent_return(self):
+        """`sys.exit(1)` and `return 1` are the same intent; the preview must
+        not depend on which spelling the handler chose."""
+        exiting = self._app_with(lambda: sys.exit(1)).test(["--dry-run", "rel"])
+        returning = self._app_with(lambda: 1).test(["--dry-run", "rel"])
+        assert exiting.stdout == returning.stdout
+        assert exiting.stderr == returning.stderr
+        assert exiting.exit_code == returning.exit_code
+
+    def test_sys_exit_with_no_code_renders_the_log(self):
+        app = self._app_with(lambda: sys.exit())
+        r = app.test(["--dry-run", "rel"])
+        assert r.exit_code == 0
+        assert r.stdout == _EXPECTED_LOG
+
+    def test_sys_exit_renders_nothing_outside_dry_mode(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        app = self._app_with(lambda: sys.exit(1))
+        r = app.test(["rel"])
+        assert r.exit_code == 1
+        assert "DRY RUN" not in r.stdout
+
+    def test_sys_exit_renders_the_log_on_the_run_path(self, monkeypatch, capsys):
+        app = self._app_with(lambda: sys.exit(1))
+        monkeypatch.setattr(sys, "argv", ["app", "--dry-run", "rel"])
+        with pytest.raises(SystemExit) as exc:
+            app.run()
+        assert exc.value.code == 1
+        captured = capsys.readouterr()
+        assert captured.out == _EXPECTED_LOG
+        assert captured.err == ""
+
+    def test_uncaught_exception_renders_the_log_marked_incomplete(
+        self, monkeypatch, capsys
+    ):
+        def _boom():
+            raise RuntimeError("kaboom")
+
+        app = self._app_with(_boom)
+        monkeypatch.setattr(sys, "argv", ["app", "--dry-run", "rel"])
+        with pytest.raises(RuntimeError, match="kaboom"):
+            app.run()
+        captured = capsys.readouterr()
+        assert captured.out == _EXPECTED_LOG
+        assert captured.err == (
+            "error: dry-run preview ends at step 2: rel aborted — "
+            "the preview above may be incomplete\n"
+        )
+
+    def test_an_aborted_preview_names_the_dotted_command_path(
+        self, monkeypatch, capsys
+    ):
+        app = _app()
+        grp = app.group("release", help="release")
+
+        @grp.command("run", help="run", effect="mutating")
+        def _run(ctx):
+            raise RuntimeError("kaboom")
+
+        monkeypatch.setattr(sys, "argv", ["app", "--dry-run", "release", "run"])
+        with pytest.raises(RuntimeError):
+            app.run()
+        captured = capsys.readouterr()
+        assert captured.out == "DRY RUN — no changes were made. Would do:\n"
+        assert "release.run aborted" in captured.err
+
+    def test_uncaught_exception_renders_nothing_outside_dry_mode(
+        self, monkeypatch, capsys, tmp_path
+    ):
+        monkeypatch.chdir(tmp_path)
+
+        def _boom():
+            raise RuntimeError("kaboom")
+
+        app = self._app_with(_boom)
+        monkeypatch.setattr(sys, "argv", ["app", "--yes", "rel"])
+        with pytest.raises(RuntimeError):
+            app.run()
+        captured = capsys.readouterr()
+        assert "DRY RUN" not in captured.out
+        assert "aborted" not in captured.err
+
+    def test_bad_handler_return_renders_the_log_marked_incomplete(
+        self, monkeypatch, capsys
+    ):
+        app = self._app_with(lambda: ["not", "an", "outcome"])
+        monkeypatch.setattr(sys, "argv", ["app", "--dry-run", "rel"])
+        with pytest.raises(TypeError, match="command handler must return"):
+            app.run()
+        captured = capsys.readouterr()
+        assert captured.out == _EXPECTED_LOG
+        assert "rel aborted" in captured.err
+
+    def test_the_abort_marker_never_reaches_stdout(self, monkeypatch, capsys):
+        """§3.4: the log is stdout's; the marker that qualifies it is stderr's,
+        exactly like the truncation error."""
+
+        def _boom():
+            raise RuntimeError("kaboom")
+
+        app = self._app_with(_boom)
+        monkeypatch.setattr(sys, "argv", ["app", "--quiet", "--dry-run", "rel"])
+        with pytest.raises(RuntimeError):
+            app.run()
+        captured = capsys.readouterr()
+        assert "aborted" not in captured.out
+        assert captured.out == _EXPECTED_LOG
+
+    def test_a_read_only_abort_still_renders_header_with_empty_body(
+        self, monkeypatch, capsys
+    ):
+        app = _app()
+
+        @app.command("look", help="look", effect="read_only")
+        def _look(ctx):
+            raise RuntimeError("kaboom")
+
+        monkeypatch.setattr(sys, "argv", ["app", "--dry-run", "look"])
+        with pytest.raises(RuntimeError):
+            app.run()
+        captured = capsys.readouterr()
+        assert captured.out == "DRY RUN — no changes were made. Would do:\n"
+        assert "look aborted" in captured.err
+
+    def test_truncation_still_owns_its_own_rendering(self, monkeypatch, capsys):
+        """The truncation path renders itself and exits 1; the abort marker
+        must not double up on it."""
+        app = _app()
+
+        @app.command("rel", help="rel", effect="mutating")
+        def _rel(ctx):
+            u = ctx.effects.run(["git", "status"])
+            if u:
+                pass
+            return 0
+
+        monkeypatch.setattr(sys, "argv", ["app", "--dry-run", "rel"])
+        with pytest.raises(SystemExit) as exc:
+            app.run()
+        assert exc.value.code == 1
+        captured = capsys.readouterr()
+        assert captured.out == (
+            "DRY RUN — no changes were made. Would do:\n"
+            "  1. run: git status\n"
+        )
+        assert captured.err == (
+            "error: dry-run preview ends at step 2: rel branched on unsettled "
+            "value «step 1 output» — cannot preview past this point\n"
+        )
+        assert "aborted" not in captured.err
+
+
 class TestTruncation:
     def test_branching_on_a_carrier_truncates(self):
         app = _app()

{strictcli-0.35.2 → strictcli-0.35.4}/tests/test_reserved_quartet.py

@@ -127,13 +127,107 @@ class TestDelivery:
         assert r.exit_code == 0
         assert seen == {"ok": True}
 
-    def test_pre_scan_is_position_aware(self):
-        """The quartet is extracted from the pre-command region only, which is
-        what keeps a passthrough command's args opaque to the framework."""
+    @pytest.mark.parametrize("token,key", [
+        ("--dry-run", "dry_run"),
+        ("--yes", "yes"),
+        ("--quiet", "quiet"),
+        ("--verbose", "verbose"),
+    ])
+    def test_each_flag_is_recognized_after_the_command(self, token, key):
+        """The quartet is recognized anywhere in argv, exactly like --help."""
+        r = _quartet_app().test(["run", token])
+        assert r.exit_code == 0
+        assert r.data[key] is True
+
+    def test_all_four_together_after_the_command(self):
+        r = _quartet_app().test(["run", "--dry-run", "--yes", "--quiet", "--verbose"])
+        assert r.exit_code == 0
+        assert r.data == {"dry_run": True, "yes": True, "quiet": True, "verbose": True}
+
+    def test_mixed_positions_are_unioned(self):
+        r = _quartet_app().test(["--dry-run", "run", "--verbose"])
+        assert r.exit_code == 0
+        assert r.data["dry_run"] is True
+        assert r.data["verbose"] is True
+
+    def test_recognized_after_a_nested_group_subcommand(self):
+        app = strictcli.App(name="app", version="1.0.0", help="app")
+        outer = app.group("outer", help="outer")
+        inner = outer.group("inner", help="inner")
+
+        @inner.command("run", effect="read_only", help="run")
+        def _run(ctx):
+            return strictcli.outcome(data={"dry_run": ctx.dry_run})
+
+        r = app.test(["outer", "inner", "run", "--dry-run"])
+        assert r.exit_code == 0
+        assert r.data == {"dry_run": True}
+
+    def test_recognized_between_a_group_and_its_subcommand(self):
+        app = strictcli.App(name="app", version="1.0.0", help="app")
+        grp = app.group("grp", help="grp")
+
+        @grp.command("run", effect="read_only", help="run")
+        def _run(ctx):
+            return strictcli.outcome(data={"dry_run": ctx.dry_run})
+
+        r = app.test(["grp", "--dry-run", "run"])
+        assert r.exit_code == 0
+        assert r.data == {"dry_run": True}
+
+    def test_stripped_from_argv_after_the_command(self):
+        """The quartet never reaches the command parser as an argument."""
+        app = strictcli.App(name="app", version="1.0.0", help="app")
+
+        @app.command("run", effect="read_only", help="run",
+                     args=[strictcli.Arg(name="name", help="a positional")])
+        def _run(ctx, name):
+            return strictcli.outcome(data={"name": name, "quiet": ctx.quiet})
+
+        r = app.test(["run", "--quiet", "value"])
+        assert r.exit_code == 0
+        assert r.data == {"name": "value", "quiet": True}
+
+    def test_a_token_after_double_dash_is_data(self):
+        """A bare -- ends the scan: what follows is positional data."""
+        app = strictcli.App(name="app", version="1.0.0", help="app")
+
+        @app.command("run", effect="read_only", help="run",
+                     args=[strictcli.Arg(name="rest", help="trailing args",
+                                         variadic=True)])
+        def _run(ctx, rest):
+            return strictcli.outcome(data={"rest": rest, "dry_run": ctx.dry_run})
+
+        r = app.test(["run", "--", "--dry-run"])
+        assert r.exit_code == 0
+        assert r.data == {"rest": ["--dry-run"], "dry_run": False}
+
+    def test_hermetic_stays_pre_command_only(self):
+        """Only the quartet moved; --hermetic is still pre-command-only."""
         app = _quartet_app()
-        r = app.test(["run", "--dry-run"])
+        r = app.test(["run", "--hermetic"])
         assert r.exit_code == 1
-        assert "unknown flag '--dry-run'" in r.stderr
+        assert "unknown flag '--hermetic'" in r.stderr
+
+    def test_read_only_accepts_a_post_command_dry_run(self):
+        app = _quartet_app()
+        r = app.test(["run", "--dry-run"])
+        assert r.exit_code == 0
+        assert "DRY RUN — no changes were made. Would do:" in r.stdout
+
+    def test_read_only_still_rejects_a_mutating_effect_post_command(self):
+        """Per-command applicability is unchanged, wherever --dry-run appeared."""
+        app = strictcli.App(name="app", version="1.0.0", help="app")
+
+        @app.command("look", effect="read_only", help="look")
+        def _look(ctx):
+            ctx.effects.mkdir("d")
+            return 0
+
+        with pytest.raises(ValueError) as exc:
+            app.test(["look", "--dry-run"])
+        assert ('command "look" is classified read_only; '
+                "effects.mkdir is a mutating operation") in str(exc.value)
 
     def test_passthrough_args_stay_opaque(self):
         app = strictcli.App(name="app", version="1.0.0", help="app")
@@ -152,6 +246,46 @@ class TestDelivery:
         assert r.exit_code == 0
         assert seen["args"] == ["--quiet", "--verbose"]
 
+    def test_passthrough_under_a_group_stays_opaque(self):
+        app = strictcli.App(name="app", version="1.0.0", help="app")
+        seen = {}
+
+        def _pt(ctx, name, args, globals):
+            seen["args"] = args
+            seen["verbose"] = ctx.verbose
+            return 0
+
+        grp = app.group("grp", help="grp")
+
+        @grp.command("exec", effect="read_only", help="exec",
+                     passthrough=strictcli.Passthrough(handler=_pt))
+        def _exec(ctx, **kw):
+            return 0
+
+        r = app.test(["grp", "exec", "--verbose", "child"])
+        assert r.exit_code == 0
+        assert seen == {"args": ["--verbose", "child"], "verbose": False}
+
+    def test_pre_command_position_is_the_passthrough_escape_hatch(self):
+        """A pre-command quartet token reaches the Context AND leaves the
+        child's identically-spelled argument untouched."""
+        app = strictcli.App(name="app", version="1.0.0", help="app")
+        seen = {}
+
+        def _pt(ctx, name, args, globals):
+            seen["args"] = args
+            seen["verbose"] = ctx.verbose
+            return 0
+
+        @app.command("exec", effect="read_only", help="exec",
+                     passthrough=strictcli.Passthrough(handler=_pt))
+        def _exec(ctx, **kw):
+            return 0
+
+        r = app.test(["--verbose", "exec", "--verbose", "child"])
+        assert r.exit_code == 0
+        assert seen == {"args": ["--verbose", "child"], "verbose": True}
+
 
 class TestGating:
     """The --quiet/--verbose gating table (quiet dominates verbose)."""

{strictcli-0.35.2 → strictcli-0.35.4}/uv.lock

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