strictcli 0.14.0__tar.gz → 0.15.1__tar.gz

strictcli-0.15.1/.rlsbl/changes/.validated

@@ -0,0 +1 @@
+4df925097e74f9a99e5ece43f3df2cd90f7b3e17

strictcli-0.15.1/.rlsbl/changes/0.15.0.jsonl

@@ -0,0 +1,6 @@
+{"commits":["057edc5200703fe2a2d37d28f488833b35254a06"],"user_facing":false}
+{"commits":["e6af4e228227d55585c09ec9012cca846eff2651"],"user_facing":false}
+{"commits":["e5dc999d0d920ba0737d2c565be818af8465de1c"],"user_facing":true,"description":"**Breaking.** `config set` now validates keys against registered flags and rejects unknown keys.","type":"breaking"}
+{"commits":["e5dc999d0d920ba0737d2c565be818af8465de1c"],"user_facing":true,"description":"**New feature.** `config set` coerces values to the flag's declared type (int, bool, float) before writing to config.","type":"feature"}
+{"commits":["4cf2df20f76491a8d9b504307de8d78ca514e7ab"],"user_facing":false}
+{"commits":["050a53f9af245a308f6d5895307beb7f479c9c27"],"user_facing":false}

strictcli-0.15.1/.rlsbl/changes/0.15.0.md

@@ -0,0 +1,9 @@
+## 0.15.0
+
+### Breaking
+
+- **Breaking.** `config set` now validates keys against registered flags and rejects unknown keys.
+
+### Features
+
+- **New feature.** `config set` coerces values to the flag's declared type (int, bool, float) before writing to config.

strictcli-0.15.1/.rlsbl/changes/0.15.1.jsonl

@@ -0,0 +1,6 @@
+{"commits":["face7b1fcf296fcd3ba1d5d7b15194c71f79ac0c"],"user_facing":true,"description":"**Breaking.** Config set now accepts negative numeric values. Unknown single-dash tokens produce 'unexpected argument' instead of 'unknown flag'.","type":"breaking"}
+{"commits":["d4bbb758e89f174279d3d1a281ded985c47c958a"],"user_facing":true,"description":"**Fix.** Config show now outputs lowercase true/false for bool values, matching Go implementation.","type":"fix"}
+{"commits":["b2bdcfa7388ac5904c5da98a017c4248cc2737ea"],"user_facing":false}
+{"commits":["053285501d0c135dffc782f038ac4f35881bcd89"],"user_facing":false}
+{"commits":["48504dbc7255e89a73c663f4745eaf7a64ec0466"],"user_facing":false}
+{"commits":["ca62cef3775568ecda2e7bdadf04ee813608d9d6"],"user_facing":false}

strictcli-0.15.1/.rlsbl/changes/0.15.1.md

@@ -0,0 +1,9 @@
+## 0.15.1
+
+### Breaking
+
+- **Breaking.** Config set now accepts negative numeric values. Unknown single-dash tokens produce 'unexpected argument' instead of 'unknown flag'.
+
+### Fixes
+
+- **Fix.** Config show now outputs lowercase true/false for bool values, matching Go implementation.

strictcli-0.15.1/.rlsbl/config.json

@@ -0,0 +1,12 @@
+{
+  "targets": [
+    "pypi",
+    "npm"
+  ],
+  "private": false,
+  "push_timeout": 300,
+  "pipelines": {
+    "pypi": {"type": "pypi", "local": false},
+    "npm": {"type": "npm", "local": false}
+  }
+}

strictcli-0.15.1/.rlsbl/releases/v0.15.0.toml

@@ -0,0 +1,8 @@
+# Version bump type: patch, minor, or major
+bump = "minor"
+# Short description of this release (required)
+description = "Config set type coercion and key validation"
+# Optional context explaining why these changes were made
+context = "config set now validates keys against registered flags and coerces string values to the flag's declared type before writing. This is a breaking change: unknown keys are rejected."
+include = ["pypi", "npm"]
+exclude = []

strictcli-0.15.1/.rlsbl/releases/v0.15.1.toml

@@ -0,0 +1,8 @@
+# Version bump type: patch, minor, or major
+bump = "patch"
+# Short description of this release (required)
+description = "Config show bool parity and negative values in config set"
+# Optional context explaining why these changes were made
+context = "config show now outputs lowercase true/false matching Go. config set accepts negative numeric values."
+include = ["pypi", "npm"]
+exclude = []

strictcli-0.15.1/.rlsbl/version

@@ -0,0 +1 @@
+0.63.0

{strictcli-0.14.0 → strictcli-0.15.1}/CHANGELOG.md

@@ -2,17 +2,37 @@
 
 # Changelog
 
-## 0.14.0
+## 0.15.1
 
-checks_embed for inline TOML data
+Config show bool parity and negative values in config set
 
 <details>
 <summary>Context</summary>
 
-Adds checks_embed parameter as an alternative to checks_path, allowing TOML bytes to be passed directly without requiring a file on disk.
+config show now outputs lowercase true/false matching Go. config set accepts negative numeric values.
 
 </details>
 
+### Breaking
+
+- **Breaking.** Config set now accepts negative numeric values. Unknown single-dash tokens produce 'unexpected argument' instead of 'unknown flag'.
+
+### Fixes
+
+- **Fix.** Config show now outputs lowercase true/false for bool values, matching Go implementation.
+
+## 0.15.0
+
+### Breaking
+
+- **Breaking.** `config set` now validates keys against registered flags and rejects unknown keys.
+
+### Features
+
+- **New feature.** `config set` coerces values to the flag's declared type (int, bool, float) before writing to config.
+
+## 0.14.0
+
 ### Features
 
 - **New feature.** `checks_embed` parameter accepts raw TOML bytes, enabling inline checks configuration without a file on disk.

{strictcli-0.14.0 → strictcli-0.15.1}/PKG-INFO

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

{strictcli-0.14.0 → strictcli-0.15.1}/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "strictcli",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "strictcli",
-      "version": "0.14.0",
+      "version": "0.15.1",
       "hasInstallScript": true,
       "license": "MIT"
     }

{strictcli-0.14.0 → strictcli-0.15.1}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strictcli",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "A strict, zero-dependency CLI framework for Python (npm wrapper)",
   "main": "index.js",
   "scripts": {

{strictcli-0.14.0 → strictcli-0.15.1}/pyproject.toml

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

{strictcli-0.14.0 → strictcli-0.15.1}/strictcli/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.14.0"
+__version__ = "0.15.1"
 
 __all__ = [
     "App", "Flag", "Arg", "Tag", "MutexGroup", "CoRequired", "Requires",
@@ -125,6 +125,15 @@ def _coerce_config_value(value: object, flag: "Flag") -> object:
     raise ValueError(f"unsupported flag type {flag.type}")
 
 
+def _format_config_value(value: object) -> str:
+    """Format a config value for display, matching Go's formatConfigValue."""
+    if value is None:
+        return "<nil>"
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
 _CHECK_NAME_RE = re.compile(r"^[a-z][a-z0-9-]*$")
 _CHECK_REQUIRED_FIELDS = {"tags", "severity", "fast", "pure", "needs_network", "depends_on"}
 _CHECK_VALID_SEVERITIES = {"error", "warn"}
@@ -285,18 +294,39 @@ class _ParseError(Exception):
         self.command_prefix = command_prefix
 
 
+def _strict_bool(s: str) -> bool:
+    """Parse a boolean string strictly.
+
+    Accepts: 1, true, yes (case-insensitive) -> True
+    Accepts: 0, false, no (case-insensitive) -> False
+    Everything else raises ValueError.
+    """
+    lower = s.lower()
+    if lower in ("1", "true", "yes"):
+        return True
+    if lower in ("0", "false", "no"):
+        return False
+    raise ValueError(f"expected boolean, got '{s}'")
+
+
 def _strict_int(s: str) -> int:
     """Parse an integer string strictly -- no leading/trailing whitespace allowed.
 
     Python's int() silently strips whitespace; Go's strconv.Atoi does not.
     This matches Go's stricter behavior. Additionally, the result is
     range-checked to fit in a signed 64-bit integer, matching Go's int/int64.
+
+    All errors raise ValueError with the same message format as Go's
+    parseIntStrict: "expected integer, got '<value>'".
     """
     if s != s.strip():
-        raise ValueError(f"invalid literal for int() with base 10: {s!r}")
-    n = int(s)
+        raise ValueError(f"expected integer, got '{s}'")
+    try:
+        n = int(s)
+    except ValueError:
+        raise ValueError(f"expected integer, got '{s}'") from None
     if n < -(2**63) or n > 2**63 - 1:
-        raise ValueError("integer out of range")
+        raise ValueError(f"expected integer, got '{s}'")
     return n
 
 
@@ -1005,7 +1035,7 @@ class App:
                 else:
                     value = None
                     source = "default"
-                print(f"{param} = {value}  (source: {source})")
+                print(f"{param} = {_format_config_value(value)}  (source: {source})")
 
         config_grp.commands["show"] = Command(
             name="show",
@@ -1014,7 +1044,7 @@ class App:
         )
 
         # config set
-        def _config_set_handler(key, value, **_kw) -> None:
+        def _config_set_handler(key, value, **_kw) -> int:
             path = _config_path(
                 app_ref.name,
                 override=app_ref.config_path,
@@ -1023,26 +1053,50 @@ class App:
             dir_path = os.path.dirname(path)
             os.makedirs(dir_path, exist_ok=True)
             # Read existing config
-            existing: dict = {}
-            if os.path.isfile(path):
-                if app_ref.config_format == "toml":
-                    try:
-                        with open(path, "rb") as fh:
-                            existing = tomllib.load(fh)
-                    except (tomllib.TOMLDecodeError, UnicodeDecodeError):
-                        existing = {}
-                else:
+            existing = _load_config(
+                app_ref.name,
+                config_path_override=app_ref.config_path,
+                config_format=app_ref.config_format,
+            )
+
+            # Look up the key against registered flags
+            all_flags = app_ref._collect_all_flags()
+            matched_flag = None
+            for f in all_flags:
+                if _flag_param_name(f.name) == key:
+                    matched_flag = f
+                    break
+            if matched_flag is None:
+                print(f"config set: unknown key '{key}'", file=sys.stderr)
+                return 1
+
+            # Coerce the string value to the flag's type
+            try:
+                if matched_flag.type == bool:
+                    typed_value = _strict_bool(value)
+                elif matched_flag.type == int:
+                    typed_value = _strict_int(value)
+                elif matched_flag.type == float:
                     try:
-                        with open(path) as fh:
-                            existing = json.loads(fh.read())
-                    except (json.JSONDecodeError, ValueError):
-                        existing = {}
-            existing[key] = value
+                        typed_value = _strict_float(value)
+                    except ValueError as fe:
+                        msg = str(fe)
+                        if msg in ("NaN is not allowed", "Inf is not allowed"):
+                            raise
+                        raise ValueError(f"expected float, got '{value}'") from fe
+                else:  # str
+                    typed_value = value
+            except ValueError as e:
+                print(f"config set: key '{key}': {e}", file=sys.stderr)
+                return 1
+
+            existing[key] = typed_value
             if app_ref.config_format == "toml":
                 _write_toml_flat(existing, path)
             else:
                 with open(path, "w") as fh:
                     fh.write(json.dumps(existing, indent=2) + "\n")
+            return 0
 
         config_grp.commands["set"] = Command(
             name="set",
@@ -1253,10 +1307,8 @@ class App:
                     if f.type is int:
                         try:
                             _store_value(f, _strict_int(value_part))
-                        except ValueError:
-                            raise _ParseError(
-                                f"--{f.name}: expected integer, got {value_part!r}"
-                            )
+                        except ValueError as e:
+                            raise _ParseError(f"--{f.name}: {e}")
                     elif f.type is float:
                         try:
                             _store_value(f, _strict_float(value_part))
@@ -1297,10 +1349,8 @@ class App:
                         if f.type is int:
                             try:
                                 _store_value(f, _strict_int(raw))
-                            except ValueError:
-                                raise _ParseError(
-                                    f"--{f.name}: expected integer, got {raw!r}"
-                                )
+                            except ValueError as e:
+                                raise _ParseError(f"--{f.name}: {e}")
                         elif f.type is float:
                             try:
                                 _store_value(f, _strict_float(raw))
@@ -1328,10 +1378,8 @@ class App:
                         if f.type is int:
                             try:
                                 _store_value(f, _strict_int(raw))
-                            except ValueError:
-                                raise _ParseError(
-                                    f"--{f.name}: expected integer, got {raw!r}"
-                                )
+                            except ValueError as e:
+                                raise _ParseError(f"--{f.name}: {e}")
                         elif f.type is float:
                             try:
                                 _store_value(f, _strict_float(raw))
@@ -1362,12 +1410,9 @@ class App:
                 env_val = os.environ.get(f.env)
                 if env_val is not None:
                     if f.type is bool:
-                        lower = env_val.lower()
-                        if lower in ("1", "true", "yes"):
-                            cli_set[f.name] = True
-                        elif lower in ("0", "false", "no"):
-                            cli_set[f.name] = False
-                        else:
+                        try:
+                            cli_set[f.name] = _strict_bool(env_val)
+                        except ValueError:
                             raise _ParseError(
                                 f"invalid boolean value {env_val!r} for env var "
                                 f"'{f.env}' (flag '--{f.name}')"
@@ -1375,10 +1420,9 @@ class App:
                     elif f.type is int:
                         try:
                             coerced = _strict_int(env_val)
-                        except ValueError:
+                        except ValueError as e:
                             raise _ParseError(
-                                f"--{f.name}: expected integer, got {env_val!r} "
-                                f"(from env var '{f.env}')"
+                                f"--{f.name}: {e} (from env var '{f.env}')"
                             )
                         cli_set[f.name] = [coerced] if f.repeatable else coerced
                     elif f.type is float:
@@ -1655,8 +1699,8 @@ def _parse_command(
                 if f.type is int:
                     try:
                         _store_value(f, _strict_int(value_part))
-                    except ValueError:
-                        raise _ParseError(f"--{f.name}: expected integer, got {value_part!r}")
+                    except ValueError as e:
+                        raise _ParseError(f"--{f.name}: {e}")
                 elif f.type is float:
                     try:
                         _store_value(f, _strict_float(value_part))
@@ -1697,8 +1741,8 @@ def _parse_command(
                         if f.type is int:
                             try:
                                 _store_value(f, _strict_int(raw))
-                            except ValueError:
-                                raise _ParseError(f"--{f.name}: expected integer, got {raw!r}")
+                            except ValueError as e:
+                                raise _ParseError(f"--{f.name}: {e}")
                         elif f.type is float:
                             try:
                                 _store_value(f, _strict_float(raw))
@@ -1717,40 +1761,39 @@ def _parse_command(
             continue
 
         # -x (short form)
-        if tok.startswith("-") and len(tok) == 2:
-            if tok in short_lookup:
-                f = short_lookup[tok]
-                if f.type is bool:
-                    cli_set[f.name] = True
-                    i += 1
-                else:
-                    # str/int/float flag: consume next token as value
-                    if i + 1 < len(tokens):
-                        raw = tokens[i + 1]
-                        if f.type is int:
-                            try:
-                                _store_value(f, _strict_int(raw))
-                            except ValueError:
-                                raise _ParseError(f"--{f.name}: expected integer, got {raw!r}")
-                        elif f.type is float:
-                            try:
-                                _store_value(f, _strict_float(raw))
-                            except ValueError as e:
-                                raise _float_parse_error(f.name, raw, e)
-                        else:
-                            resolved, stdin_consumed_by[0] = _resolve_at_prefix(
-                                f.name, raw, stdin_consumed_by[0],
-                            )
-                            _store_value(f, resolved)
-                        i += 2
-                    else:
-                        raise _ParseError(f"flag '{tok}' requires a value")
+        if tok.startswith("-") and len(tok) == 2 and tok in short_lookup:
+            f = short_lookup[tok]
+            if f.type is bool:
+                cli_set[f.name] = True
+                i += 1
             else:
-                raise _ParseError(f"unknown flag '{tok}'")
+                # str/int/float flag: consume next token as value
+                if i + 1 < len(tokens):
+                    raw = tokens[i + 1]
+                    if f.type is int:
+                        try:
+                            _store_value(f, _strict_int(raw))
+                        except ValueError as e:
+                            raise _ParseError(f"--{f.name}: {e}")
+                    elif f.type is float:
+                        try:
+                            _store_value(f, _strict_float(raw))
+                        except ValueError as e:
+                            raise _float_parse_error(f.name, raw, e)
+                    else:
+                        resolved, stdin_consumed_by[0] = _resolve_at_prefix(
+                            f.name, raw, stdin_consumed_by[0],
+                        )
+                        _store_value(f, resolved)
+                    i += 2
+                else:
+                    raise _ParseError(f"flag '{tok}' requires a value")
             continue
 
-        # Unknown flag-like token
-        raise _ParseError(f"unknown flag '{tok}'")
+        # Token starts with "-" but doesn't match any known flag;
+        # treat as a positional arg (e.g. negative numbers like -7, -3.14)
+        positionals.append(tok)
+        i += 1
 
     # Step 4: resolve env vars for flags not set by CLI
     for f in cmd.flags:
@@ -1760,12 +1803,9 @@ def _parse_command(
             env_val = os.environ.get(f.env)
             if env_val is not None:
                 if f.type is bool:
-                    lower = env_val.lower()
-                    if lower in ("1", "true", "yes"):
-                        cli_set[f.name] = True
-                    elif lower in ("0", "false", "no"):
-                        cli_set[f.name] = False
-                    else:
+                    try:
+                        cli_set[f.name] = _strict_bool(env_val)
+                    except ValueError:
                         raise _ParseError(
                             f"invalid boolean value {env_val!r} for env var "
                             f"'{f.env}' (flag '--{f.name}')"
@@ -1773,10 +1813,9 @@ def _parse_command(
                 elif f.type is int:
                     try:
                         coerced = _strict_int(env_val)
-                    except ValueError:
+                    except ValueError as e:
                         raise _ParseError(
-                            f"--{f.name}: expected integer, got {env_val!r} "
-                            f"(from env var '{f.env}')"
+                            f"--{f.name}: {e} (from env var '{f.env}')"
                         )
                     cli_set[f.name] = [coerced] if f.repeatable else coerced
                 elif f.type is float:

{strictcli-0.14.0 → strictcli-0.15.1}/tests/test_config.py

@@ -183,7 +183,34 @@ def test_config_show(tmp_path, monkeypatch):
     assert r.exit_code == 0
     assert "target = from-config  (source: config)" in r.stdout
     assert "count = 1  (source: default)" in r.stdout
-    assert "verbose = False  (source: default)" in r.stdout
+    assert "verbose = false  (source: default)" in r.stdout
+
+
+# --- Test 10b: config show formats bools as lowercase (Go parity) ---
+
+def test_config_show_lowercase_bools(tmp_path, monkeypatch):
+    """Config show formats bools as lowercase true/false, matching Go output."""
+    config_home = _write_config(tmp_path, "testapp", {"verbose": True})
+    monkeypatch.setenv("XDG_CONFIG_HOME", config_home)
+    app = _make_config_app(config=True)
+    r = app.test(["config", "show"])
+    assert r.exit_code == 0
+    # Bool from config must be lowercase
+    assert "verbose = true  (source: config)" in r.stdout
+    # None (no default for bool) must show as <nil>
+    assert "verbose = True" not in r.stdout
+    assert "verbose = False" not in r.stdout
+
+
+def test_config_show_bool_false_default_lowercase(tmp_path, monkeypatch):
+    """Config show formats default False bool as lowercase false."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    app = _make_config_app(config=True)
+    r = app.test(["config", "show"])
+    assert r.exit_code == 0
+    # verbose has no explicit default, defaults to False -- must be lowercase
+    assert "verbose = false  (source: default)" in r.stdout
+    assert "verbose = False" not in r.stdout
 
 
 # --- Test 11: config respects XDG_CONFIG_HOME ---