strictcli 0.23.0__tar.gz → 0.24.2__tar.gz

strictcli-0.24.2/.github/workflows/ci-pypi.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+# Per-SHA group: re-runs of the same commit dedupe, but a new commit never
+# cancels an earlier commit's in-flight run (release CI conclusions stay intact).
+concurrency:
+  group: ${{ github.workflow_ref }}-${{ github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # requires-python: >= 3.11
+        python-version: ["3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v7
+      - run: uv python install ${{ matrix.python-version }}
+      - run: uv sync --locked
+      - run: uv run python -c "import strictcli"
+      - run: uv run pytest

strictcli-0.24.2/.github/workflows/publish.yml

@@ -0,0 +1,152 @@
+name: Publish
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+concurrency:
+  group: ${{ github.workflow_ref }}-${{ github.ref }}
+  cancel-in-progress: false
+permissions:
+  contents: read
+  id-token: write
+jobs:
+  gate:
+    name: Gate on CI
+    runs-on: ubuntu-latest
+    permissions:
+      checks: read
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      GATE_TIMEOUT_MINUTES: '20'
+      GATE_GRACE_MINUTES: '5'
+      GATE_POLL_SECONDS: '15'
+      CI_CHECK_REGEX: ^(test)( \(.*\))?$
+    steps:
+      - name: Wait for CI to succeed on the release commit
+        run: |
+          set -euo pipefail
+
+          # Ref-based commit resolution: GITHUB_SHA is the tag's commit for both
+          # release-triggered runs and workflow_dispatch retries at the tag ref.
+          # Never read the release event payload -- dispatch retries have none.
+          sha="$GITHUB_SHA"
+          echo "Publish gate: waiting for CI on $GITHUB_REF_NAME (commit $sha)"
+          echo "Check-run name filter: $CI_CHECK_REGEX"
+          # Timeout, grace window, and poll interval come from the job env above;
+          # edit them there if this repository's CI needs different limits.
+
+          now() { date +%s; }
+          start="$(now)"
+          deadline=$(( start + GATE_TIMEOUT_MINUTES * 60 ))
+          grace_deadline=$(( start + GATE_GRACE_MINUTES * 60 ))
+
+          while :; do
+            if ! resp="$(gh api --paginate "repos/$GITHUB_REPOSITORY/commits/$sha/check-runs?per_page=100")"; then
+              echo "Checks API request failed; retrying in ${GATE_POLL_SECONDS}s..."
+              sleep "$GATE_POLL_SECONDS"
+              continue
+            fi
+            # Match this project's CI check runs by name; exclude check runs that
+            # belong to THIS workflow run (the gate itself and the queued publish
+            # jobs would otherwise deadlock the poll loop).
+            runs="$(jq -s --arg re "$CI_CHECK_REGEX" --arg run_id "$GITHUB_RUN_ID" '
+              [ .[].check_runs[]
+                | select(.name | test($re))
+                | select((.details_url // "") | contains("/actions/runs/" + $run_id + "/") | not)
+                | {name, status, conclusion} ]' <<< "$resp")"
+            total="$(jq 'length' <<< "$runs")"
+
+            if [ "$total" -eq 0 ]; then
+              if [ "$(now)" -ge "$grace_deadline" ]; then
+                echo "::error::Publish gate: no CI check runs matching $CI_CHECK_REGEX appeared on $sha within $GATE_GRACE_MINUTES minutes."
+                echo "A scaffolded repository always has a CI workflow, so the release commit must produce CI check runs."
+                echo "If CI jobs were renamed, update CI_CHECK_REGEX in this workflow's gate job to match the new names."
+                exit 1
+              fi
+              echo "No matching CI check runs yet; retrying in ${GATE_POLL_SECONDS}s..."
+              sleep "$GATE_POLL_SECONDS"
+              continue
+            fi
+
+            pending="$(jq '[ .[] | select(.status != "completed") ] | length' <<< "$runs")"
+            if [ "$pending" -gt 0 ]; then
+              if [ "$(now)" -ge "$deadline" ]; then
+                echo "::error::Publish gate: timed out after $GATE_TIMEOUT_MINUTES minutes waiting for CI to complete on $sha."
+                jq -r '.[] | "  \(.name): status=\(.status) conclusion=\(.conclusion // "none")"' <<< "$runs"
+                exit 1
+              fi
+              echo "$pending of $total matching CI check runs still running; retrying in ${GATE_POLL_SECONDS}s..."
+              sleep "$GATE_POLL_SECONDS"
+              continue
+            fi
+
+            not_success="$(jq '[ .[] | select(.conclusion != "success") ]' <<< "$runs")"
+            if [ "$(jq 'length' <<< "$not_success")" -gt 0 ]; then
+              echo "::error::Publish gate: CI did not pass on $sha -- refusing to publish."
+              jq -r '.[] | "  \(.name): \(.conclusion)"' <<< "$not_success"
+              while IFS= read -r conclusion; do
+                case "$conclusion" in
+                  failure|timed_out)
+                    echo "CI concluded '$conclusion' on the release commit. Fix the failure, re-run the CI workflow to green on this exact commit (gh run rerun <run-id>), then re-dispatch this publish workflow at the tag ref: gh workflow run <publish workflow> --ref $GITHUB_REF_NAME"
+                    ;;
+                  cancelled)
+                    echo "A CI check run was CANCELLED. A cancelled run proves nothing about the commit, so the gate treats it as a hard failure instead of waiting for a conclusion that will never come. Re-run the cancelled CI workflow (gh run rerun <run-id>), then re-dispatch this publish workflow at the tag ref."
+                    ;;
+                  skipped)
+                    echo "A CI check run matching the filter was SKIPPED. The gate cannot treat a skipped check as passing: this project's own CI must actually run on the release commit. Check paths filters and job conditions, re-run CI on this commit, then re-dispatch this publish workflow at the tag ref."
+                    ;;
+                  *)
+                    echo "CI check concluded '$conclusion' (not success). The gate only proceeds when every matching check concluded success."
+                    ;;
+                esac
+              done <<< "$(jq -r '.[].conclusion' <<< "$not_success" | sort -u)"
+              exit 1
+            fi
+
+            echo "Publish gate: all $total matching CI check runs succeeded."
+            jq -r '.[] | "  \(.name): \(.conclusion)"' <<< "$runs"
+            exit 0
+          done
+  pypi:
+    needs: gate
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v7
+      - run: uv build --out-dir dist
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+  npm:
+    needs: gate
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+      - name: Check if already published
+        id: check-npm
+        run: |
+          PKG_NAME=$(node -p "require('./package.json').name")
+          PKG_VERSION=$(node -p "require('./package.json').version")
+          if npm view "${PKG_NAME}@${PKG_VERSION}" version 2>/dev/null; then
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+            echo "Already published: ${PKG_NAME}@${PKG_VERSION}"
+          fi
+      - name: Determine dist-tag
+        id: dist-tag
+        run: |
+          PKG_VERSION=$(node -p "require('./package.json').version")
+          if echo "$PKG_VERSION" | grep -q '-'; then
+            PREID=$(echo "$PKG_VERSION" | sed 's/[^-]*-//' | sed 's/\.[^.]*$//')
+            echo "tag=--tag $PREID" >> "$GITHUB_OUTPUT"
+          else
+            echo "tag=" >> "$GITHUB_OUTPUT"
+          fi
+      - run: npm publish --provenance --access public ${{ 
+          steps.dist-tag.outputs.tag }}
+        if: steps.check-npm.outputs.skip != 'true'
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

{strictcli-0.23.0 → strictcli-0.24.2}/.gitignore

@@ -13,3 +13,5 @@ dist/
 .env
 .env.local
 *.local-only
+
+.rlsbl-monorepo/lock

strictcli-0.24.2/.rlsbl/config.json

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

{strictcli-0.23.0 → strictcli-0.24.2}/.rlsbl/hashes.json

@@ -1,8 +1,8 @@
 {
   ".github/workflows/ci.yml": "b4e075171b131d25f9cce55a3e3a30732e95a2a794af00f354ee3200626d6a04",
-  ".github/workflows/publish.yml": "e77dcd0b5d1c1abae5424e5f3b73862f44f06b5d46209cbe71bc04d6baa6b5be",
+  ".github/workflows/publish.yml": "20db711b8a7745c3ab41814b827e946d60e937e82ee3984e86f39567717199b1",
   "CHANGELOG.md": "7a6ec46141007c18090a0ff325e2dd68cd51588c4e0b5af7b580365e5eaaca85",
-  ".gitignore": "c89d76c6c43e7f0897b3472a15b7c0103e0be5b3a04c2b44e585fa48bdcda2bb",
+  ".gitignore": "c0582f9b1c640f9f9a8acbbe02cd19fff50e66cc595f25e129b7cc9b6cd357db",
   "LICENSE": "e958892abc1dd5d991fca6d528e695d335f25773d373d2e0be5f4a9507d8f8d5",
   "CLAUDE.md": "7294b791570185dc31020dadb092b5b79681ba8ee932fe9a3974e27eaae56c4f",
   ".rlsbl/hooks/pre-release.sh": "b2dc17c243d0b1a2c1e23c1c25db6f94878596df81dc76c41b32d95f740a7d44",
@@ -12,5 +12,6 @@
   ".rlsbl/lint/python.toml": "9cfbcef2e010d5fad243437bf2fd8df54a1fae70ee0762f9d11da70fe207501c",
   ".rlsbl/lint/go.toml": "807d5cf760baad6d571a5bfd43cb163efe356f7462ba9f1918d72de45f62339f",
   ".rlsbl/lint/npm.toml": "baa36014e65923d8cc5c8b83c77fa651da79351627570476402da66840027645",
-  ".npmignore": "7c0eea9785c0318aeb39bf8b670ce8384f4a5b812fde69ce23d7d018057325a3"
+  ".npmignore": "7c0eea9785c0318aeb39bf8b670ce8384f4a5b812fde69ce23d7d018057325a3",
+  ".github/workflows/ci-pypi.yml": "6bde3f6dd33979636f6a8f51721f85519c4d2b6106cb9c9fa78e540df26471c4"
 }

strictcli-0.24.2/.rlsbl/managed-files.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "files": {
+    ".github/workflows/ci-pypi.yml": "6bde3f6dd33979636f6a8f51721f85519c4d2b6106cb9c9fa78e540df26471c4",
+    ".npmignore": "7c0eea9785c0318aeb39bf8b670ce8384f4a5b812fde69ce23d7d018057325a3",
+    ".github/workflows/publish.yml": "20db711b8a7745c3ab41814b827e946d60e937e82ee3984e86f39567717199b1",
+    ".gitignore": "c0582f9b1c640f9f9a8acbbe02cd19fff50e66cc595f25e129b7cc9b6cd357db",
+    ".rlsbl/lint/python.toml": "9cfbcef2e010d5fad243437bf2fd8df54a1fae70ee0762f9d11da70fe207501c",
+    ".rlsbl/lint/npm.toml": "baa36014e65923d8cc5c8b83c77fa651da79351627570476402da66840027645"
+  }
+}

{strictcli-0.23.0 → strictcli-0.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strictcli
-Version: 0.23.0
+Version: 0.24.2
 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.23.0 → strictcli-0.24.2}/package-lock.json

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

{strictcli-0.23.0 → strictcli-0.24.2}/package.json

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

{strictcli-0.23.0 → strictcli-0.24.2}/pyproject.toml

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

{strictcli-0.23.0 → strictcli-0.24.2}/strictcli/__init__.py

@@ -1,8 +1,8 @@
-"""A strict, zero-dependency CLI framework for Python."""
+"""A strict, zero-dependency CLI framework for Python with mandatory help text, type-safe flags, groups, and schema export."""
 
 from __future__ import annotations
 
-__version__ = "0.23.0"
+__version__ = "0.24.2"
 
 __all__ = [
     "App", "Flag", "Arg", "FlagSet", "MutexGroup", "CoRequired", "Requires",
@@ -1484,7 +1484,38 @@ class Arg:
                     )
         # Validate default type matches declared type
         if not isinstance(self.default, _MissingSentinel) and self.default is not None:
-            if self.type is int:
+            if self.compound == "list":
+                # self.type was normalized to the item type above; the
+                # default itself must be a list of that item type.
+                if not isinstance(self.default, list):
+                    raise ValueError(
+                        f'Arg "{self.name}": list arg default must be a list'
+                    )
+                if len(self.default) == 0:
+                    raise ValueError(
+                        f'Arg "{self.name}": explicit empty default is '
+                        f"redundant for list args, omit the default"
+                    )
+                type_name = {str: "str", int: "int", float: "float"}[self.type]
+                for i, elem in enumerate(self.default):
+                    if self.type is str:
+                        valid = isinstance(elem, str)
+                    elif self.type is int:
+                        valid = isinstance(elem, int) and not isinstance(elem, bool)
+                    else:  # float
+                        valid = (
+                            isinstance(elem, (int, float))
+                            and not isinstance(elem, bool)
+                        )
+                        if valid and isinstance(elem, int):
+                            # Auto-coerce int to float, mirroring list flag defaults
+                            self.default[i] = float(elem)
+                    if not valid:
+                        raise ValueError(
+                            f'Arg "{self.name}": default element {i} '
+                            f"is not of type {type_name}"
+                        )
+            elif self.type is int:
                 if not isinstance(self.default, int) or isinstance(self.default, bool):
                     raise ValueError(
                         f'Arg "{self.name}": type=int requires an int default, '
@@ -1502,6 +1533,12 @@ class Arg:
                         f'Arg "{self.name}": type=bool requires a bool default, '
                         f"got {type(self.default).__name__!r}"
                     )
+            elif self.type is str:
+                if not isinstance(self.default, str):
+                    raise ValueError(
+                        f'Arg "{self.name}": type=str requires a str default, '
+                        f"got {type(self.default).__name__!r}"
+                    )
         # Validate default is in choices
         if self.choices is not None and not isinstance(self.default, _MissingSentinel) and self.default is not None:
             if self.default not in self.choices:
@@ -3185,21 +3222,8 @@ class App:
 
         # Validate choices for global flags
         for f in self._global_flags:
-            if f.choices is not None and f.name in cli_set:
-                if f.repeatable:
-                    for val in cli_set[f.name]:
-                        if val not in f.choices:
-                            choices_str = ", ".join(str(c) for c in f.choices)
-                            raise _ParseError(
-                                f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                            )
-                else:
-                    val = cli_set[f.name]
-                    if val not in f.choices:
-                        choices_str = ", ".join(str(c) for c in f.choices)
-                        raise _ParseError(
-                            f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                        )
+            if f.name in cli_set:
+                _validate_choices(f.name, cli_set[f.name], f.repeatable, f.choices)
 
         return cli_set, remaining
 
@@ -3754,6 +3778,39 @@ def _tokens_contain_help(tokens: list[str]) -> bool:
     return False
 
 
+def _validate_choices(
+    name: str,
+    val: object,
+    repeatable: bool,
+    choices: list | None,
+    *,
+    is_arg: bool = False,
+) -> None:
+    """Validate a resolved flag or arg value against its choices list.
+
+    Raises _ParseError on an invalid value. is_arg selects the message prefix
+    ("argument 'name':" instead of "--name:"); the two f-strings are kept as
+    full literals so conformance/check_error_parity.py can extract them.
+    A None value is exempt from validation: None only arises when the flag or
+    arg was not passed (an unset mutex flag, or default=None on an arg) -- a
+    CLI-supplied value is never None.
+    """
+    if choices is None or val is None:
+        return
+    vals = val if repeatable else [val]
+    for v in vals:
+        if v not in choices:
+            choices_str = ", ".join(str(c) for c in choices)
+            if is_arg:
+                raise _ParseError(
+                    f"argument '{name}': invalid value '{v}', "
+                    f"must be one of: {choices_str}"
+                )
+            raise _ParseError(
+                f"--{name}: invalid value '{v}', must be one of: {choices_str}"
+            )
+
+
 def _validate_and_build_kwargs(
     cmd: Command,
     cli_set: dict[str, object],
@@ -3849,21 +3906,8 @@ def _validate_and_build_kwargs(
 
     # Step 5.5: validate choices
     for f in cmd.flags:
-        if f.choices is not None and f.name in cli_set:
-            if f.repeatable:
-                for val in cli_set[f.name]:
-                    if val not in f.choices:
-                        choices_str = ", ".join(str(c) for c in f.choices)
-                        raise _ParseError(
-                            f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                        )
-            else:
-                val = cli_set[f.name]
-                if val not in f.choices:
-                    choices_str = ", ".join(str(c) for c in f.choices)
-                    raise _ParseError(
-                        f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                    )
+        if f.name in cli_set:
+            _validate_choices(f.name, cli_set[f.name], f.repeatable, f.choices)
 
     # Step 5.6: custom validation
     for f in cmd.flags:
@@ -3874,7 +3918,9 @@ def _validate_and_build_kwargs(
                         f.validate(val)
                     except ValueError as e:
                         raise _ParseError(f"--{f.name}: {e}")
-            else:
+            elif cli_set[f.name] is not None:
+                # None means the flag was not passed (an unset mutex flag) --
+                # there is no value to validate.
                 try:
                     f.validate(cli_set[f.name])
                 except ValueError as e:
@@ -3904,23 +3950,10 @@ def _validate_and_build_kwargs(
 
     # Step 6.5: validate arg choices
     for a in cmd.args:
-        if a.choices is not None and a.name in arg_values:
-            val = arg_values[a.name]
-            if a.variadic:
-                for v in val:
-                    if v not in a.choices:
-                        choices_str = ", ".join(str(c) for c in a.choices)
-                        raise _ParseError(
-                            f"argument '{a.name}': invalid value '{v}', "
-                            f"must be one of: {choices_str}"
-                        )
-            else:
-                if val not in a.choices:
-                    choices_str = ", ".join(str(c) for c in a.choices)
-                    raise _ParseError(
-                        f"argument '{a.name}': invalid value '{val}', "
-                        f"must be one of: {choices_str}"
-                    )
+        if a.name in arg_values:
+            _validate_choices(
+                a.name, arg_values[a.name], a.variadic, a.choices, is_arg=True,
+            )
 
     # Step 7: build kwargs dict (command flags only)
     kwargs: dict[str, object] = {}
@@ -5274,15 +5307,22 @@ def _run_checks(
     warn with ignore_warnings=True), 1 otherwise.
     """
     results: list[tuple[str, CheckResult]] = []
+    # Checks whose dependents should be cascade-skipped: only fail or
+    # cascade-skip qualifies. A warn satisfies the dependency (dependents
+    # still run) regardless of ignore_warnings -- it only affects the exit
+    # code. Explicit skip from an impl is not a failure either.
     failed_checks: set[str] = set()
     exit_code = 0
 
-    # Build reverse dependency map for this execution set
-    dependents_of: dict[str, set[str]] = {name: set() for name in check_names}
-    for name in check_names:
-        for dep in check_defs[name].depends_on:
-            if dep in dependents_of:
-                dependents_of[dep].add(name)
+    def record(name: str, result: CheckResult) -> None:
+        nonlocal exit_code
+        if result.status == "fail":
+            failed_checks.add(name)
+            exit_code = 1
+        elif result.status == "warn":
+            if not ignore_warnings:
+                exit_code = 1
+        # "skip" from an impl or adapter: no cascade, no exit code change.
 
     for name in check_names:
         cdef = check_defs[name]
@@ -5309,33 +5349,14 @@ def _run_checks(
         if cdef.scope and scope_adapter is not None:
             adapted = scope_adapter(context, cdef.scope)
             if isinstance(adapted, CheckResult):
-                result = adapted
-                results.append((name, result))
-                if result.status == "fail":
-                    failed_checks.add(name)
-                    exit_code = 1
-                elif result.status == "warn":
-                    if not ignore_warnings:
-                        failed_checks.add(name)
-                        exit_code = 1
-                elif result.status == "skip":
-                    pass
+                results.append((name, adapted))
+                record(name, adapted)
                 continue
             check_context = adapted
 
         result = cdef.impl(check_context)
         results.append((name, result))
-
-        if result.status == "fail":
-            failed_checks.add(name)
-            exit_code = 1
-        elif result.status == "warn":
-            if not ignore_warnings:
-                failed_checks.add(name)
-                exit_code = 1
-        elif result.status == "skip":
-            # Treat explicit skip from impl as non-failure (no cascade)
-            pass
+        record(name, result)
 
     return results, exit_code
 

strictcli-0.24.2/tests/test_arg_default_validation.py

@@ -0,0 +1,79 @@
+"""Registration-time validation of arg defaults.
+
+str args must reject non-string defaults, and list (variadic) args must
+validate their default as a list with correctly-typed elements.
+"""
+
+import pytest
+
+import strictcli
+
+
+def test_arg_str_default_type_validated():
+    """type=str requires a str default."""
+    with pytest.raises(ValueError, match="type=str requires a str default"):
+        strictcli.Arg(name="x", help="a value", required=False, default=42)
+
+
+def test_arg_str_default_rejects_bool():
+    """type=str rejects a bool default."""
+    with pytest.raises(ValueError, match="type=str requires a str default"):
+        strictcli.Arg(name="x", help="a value", required=False, default=True)
+
+
+def test_arg_list_default_must_be_list():
+    """A list arg default must be a list."""
+    with pytest.raises(ValueError, match="list arg default must be a list"):
+        strictcli.Arg(
+            name="items", help="the items", type=list[str],
+            variadic=True, required=False, default="nope",
+        )
+
+
+def test_arg_list_default_empty_rejected():
+    """An explicit empty list default is redundant and rejected."""
+    with pytest.raises(
+        ValueError,
+        match="explicit empty default is redundant for list args",
+    ):
+        strictcli.Arg(
+            name="items", help="the items", type=list[str],
+            variadic=True, required=False, default=[],
+        )
+
+
+def test_arg_list_default_element_type_validated():
+    """Element types of a list arg default are validated."""
+    with pytest.raises(ValueError, match="default element 1 is not of type str"):
+        strictcli.Arg(
+            name="items", help="the items", type=list[str],
+            variadic=True, required=False, default=["a", 2],
+        )
+
+
+def test_arg_list_default_int_element_type_validated():
+    """Element types of an int list arg default are validated."""
+    with pytest.raises(ValueError, match="default element 0 is not of type int"):
+        strictcli.Arg(
+            name="nums", help="the numbers", type=list[int],
+            variadic=True, required=False, default=["1"],
+        )
+
+
+def test_arg_list_default_valid_str():
+    """A well-typed list default is accepted."""
+    a = strictcli.Arg(
+        name="items", help="the items", type=list[str],
+        variadic=True, required=False, default=["a", "b"],
+    )
+    assert a.default == ["a", "b"]
+
+
+def test_arg_list_default_float_coerces_int():
+    """Int elements in a float list default are coerced to float."""
+    a = strictcli.Arg(
+        name="ratios", help="the ratios", type=list[float],
+        variadic=True, required=False, default=[1, 2.5],
+    )
+    assert a.default == [1.0, 2.5]
+    assert isinstance(a.default[0], float)

{strictcli-0.23.0 → strictcli-0.24.2}/tests/test_check_runner.py

@@ -267,7 +267,10 @@ class TestRunChecks:
         assert exit_code == 1
         assert results[0][1].status == "warn"
 
-    def test_warn_cascades_skip_when_not_ignored(self, tmp_path, monkeypatch):
+    def test_warn_dependency_runs_dependent(self, tmp_path, monkeypatch):
+        # A warn satisfies a dependency: only fail (or cascade-skip) skips
+        # dependents. The warn still makes the run exit non-zero when
+        # ignore_warnings=False, but the dependent must run.
         defs = {
             "b": _make_check_def(
                 "b",
@@ -286,7 +289,66 @@ class TestRunChecks:
         assert exit_code == 1
         statuses = {name: r.status for name, r in results}
         assert statuses["b"] == "warn"
-        assert statuses["a"] == "skip"
+        assert statuses["a"] == "pass"
+
+    def test_warn_dependency_transitive_dependents_run(self, tmp_path, monkeypatch):
+        # warn -> dependent -> transitive dependent: the whole chain runs.
+        defs = {
+            "c": _make_check_def(
+                "c",
+                impl=lambda ctx: CheckResult(status="warn", message="Warning"),
+            ),
+            "b": _make_check_def(
+                "b",
+                depends_on=["c"],
+                impl=lambda ctx: CheckResult(status="pass", message="B OK"),
+            ),
+            "a": _make_check_def(
+                "a",
+                depends_on=["b"],
+                impl=lambda ctx: CheckResult(status="pass", message="A OK"),
+            ),
+        }
+        app = self._make_app_with_checks(defs, tmp_path, monkeypatch)
+        ctx = SimpleContext(project_root=tmp_path)
+        order = _resolve_check_order(app._check_defs, {"a", "b", "c"})
+        results, exit_code = _run_checks(app._check_defs, order, ctx, ignore_warnings=False)
+        assert exit_code == 1
+        statuses = {name: r.status for name, r in results}
+        assert statuses["c"] == "warn"
+        assert statuses["b"] == "pass"
+        assert statuses["a"] == "pass"
+
+    def test_warn_from_scope_adapter_runs_dependent(self, tmp_path, monkeypatch):
+        # When the scope adapter short-circuits a check with a warn result,
+        # the warn must also satisfy dependencies (no cascade-skip).
+        defs = {
+            "b": _make_check_def(
+                "b",
+                impl=lambda ctx: CheckResult(status="pass", message="unused"),
+            ),
+            "a": _make_check_def(
+                "a",
+                depends_on=["b"],
+                impl=lambda ctx: CheckResult(status="pass", message="A OK"),
+            ),
+        }
+        app = self._make_app_with_checks(defs, tmp_path, monkeypatch)
+        # Give "b" a scope so the adapter is consulted for it.
+        app._check_defs["b"].scope = "some-scope"
+
+        def adapter(context, scope):
+            return CheckResult(status="warn", message="adapter warning")
+
+        ctx = SimpleContext(project_root=tmp_path)
+        order = _resolve_check_order(app._check_defs, {"a", "b"})
+        results, exit_code = _run_checks(
+            app._check_defs, order, ctx, ignore_warnings=False, scope_adapter=adapter
+        )
+        assert exit_code == 1
+        statuses = {name: r.status for name, r in results}
+        assert statuses["b"] == "warn"
+        assert statuses["a"] == "pass"
 
     def test_warn_does_not_cascade_when_ignored(self, tmp_path, monkeypatch):
         defs = {

strictcli-0.24.2/tests/test_choices_none.py

@@ -0,0 +1,163 @@
+"""Tests for choices/validate exemption of None values.
+
+A None value only arises when a flag or arg was not passed (an unset mutex
+flag, or an arg with default=None); a CLI-supplied value is never None.
+Choices validation and custom validators must skip None instead of failing
+with "invalid value 'None'".
+"""
+
+import pytest
+
+import strictcli
+
+
+# ---------------------------------------------------------------------------
+# Mutex flags: the unset member resolves to None
+# ---------------------------------------------------------------------------
+
+
+def _mutex_choices_app():
+    mg = strictcli.MutexGroup(
+        flags=[
+            strictcli.Flag(
+                name="format", type=str, help="output format",
+                default=None, choices=["text", "json"],
+            ),
+            strictcli.Flag(name="output", type=str, help="output path", default=None),
+        ],
+    )
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command("cmd", help="a command", mutex=[mg])
+    def cmd(format, output):
+        print(f"format={format} output={output}")
+
+    return app
+
+
+def test_mutex_flag_choices_unset_not_validated():
+    """Choices on an unset mutex flag must not fire when the other member is passed."""
+    app = _mutex_choices_app()
+    r = app.test(["cmd", "--output", "out.txt"])
+    assert r.exit_code == 0
+    assert "format=None output=out.txt" in r.stdout
+
+
+def test_mutex_flag_choices_passed_valid():
+    """A valid choice on the mutex flag is still accepted."""
+    app = _mutex_choices_app()
+    r = app.test(["cmd", "--format", "json"])
+    assert r.exit_code == 0
+    assert "format=json output=None" in r.stdout
+
+
+def test_mutex_flag_choices_passed_invalid():
+    """An invalid choice on the mutex flag is still rejected."""
+    app = _mutex_choices_app()
+    r = app.test(["cmd", "--format", "xml"])
+    assert r.exit_code == 1
+    assert "--format: invalid value 'xml', must be one of: text, json" in r.stderr
+
+
+# ---------------------------------------------------------------------------
+# Args: default=None (or no default) resolves to None
+# ---------------------------------------------------------------------------
+
+
+def _arg_choices_app(**arg_kwargs):
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command(
+        "cmd",
+        help="a command",
+        args=[strictcli.Arg(
+            name="env", help="target env", required=False,
+            choices=["dev", "staging", "prod"], **arg_kwargs,
+        )],
+    )
+    def cmd(env=None):
+        print(f"env={env}")
+
+    return app
+
+
+def test_arg_none_default_choices_not_passed():
+    """Optional arg with default=None and choices, not passed -> succeeds."""
+    app = _arg_choices_app(default=None)
+    r = app.test(["cmd"])
+    assert r.exit_code == 0
+    assert "env=None" in r.stdout
+
+
+def test_arg_optional_no_default_choices_not_passed():
+    """Optional arg with no default and choices, not passed -> succeeds."""
+    app = _arg_choices_app()
+    r = app.test(["cmd"])
+    assert r.exit_code == 0
+    assert "env=None" in r.stdout
+
+
+def test_arg_none_default_choices_passed_valid():
+    """A valid choice on the optional arg is still accepted."""
+    app = _arg_choices_app(default=None)
+    r = app.test(["cmd", "prod"])
+    assert r.exit_code == 0
+    assert "env=prod" in r.stdout
+
+
+def test_arg_none_default_choices_passed_invalid():
+    """An invalid choice on the optional arg is still rejected."""
+    app = _arg_choices_app(default=None)
+    r = app.test(["cmd", "local"])
+    assert r.exit_code == 1
+    assert (
+        "argument 'env': invalid value 'local', must be one of: dev, staging, prod"
+        in r.stderr
+    )
+
+
+# ---------------------------------------------------------------------------
+# Custom validators: not run for None (not-passed) values
+# ---------------------------------------------------------------------------
+
+
+def _name_validator(val):
+    if not isinstance(val, str):
+        raise ValueError(f"validator received non-string value {val!r}")
+    if val == "bad":
+        raise ValueError("bad name")
+
+
+def _mutex_validate_app():
+    mg = strictcli.MutexGroup(
+        flags=[
+            strictcli.Flag(
+                name="name", type=str, help="a name",
+                default=None, validate=_name_validator,
+            ),
+            strictcli.Flag(name="id", type=str, help="an id", default=None),
+        ],
+    )
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command("cmd", help="a command", mutex=[mg])
+    def cmd(name, id):
+        print(f"name={name} id={id}")
+
+    return app
+
+
+def test_mutex_flag_validate_unset_not_called():
+    """A custom validator must not run for an unset mutex flag (value None)."""
+    app = _mutex_validate_app()
+    r = app.test(["cmd", "--id", "42"])
+    assert r.exit_code == 0
+    assert "name=None id=42" in r.stdout
+
+
+def test_mutex_flag_validate_passed_still_runs():
+    """A passed value is still validated."""
+    app = _mutex_validate_app()
+    r = app.test(["cmd", "--name", "bad"])
+    assert r.exit_code == 1
+    assert "--name: bad name" in r.stderr

{strictcli-0.23.0 → strictcli-0.24.2}/uv.lock

@@ -232,7 +232,7 @@ wheels = [
 
 [[package]]
 name = "strictcli"
-version = "0.23.0"
+version = "0.24.2"
 source = { editable = "." }
 
 [package.dev-dependencies]

strictcli-0.23.0/.github/workflows/publish.yml

@@ -1,27 +0,0 @@
-name: Publish
-on:
-  release:
-    types: [published]
-  workflow_dispatch:
-permissions:
-  contents: read
-  id-token: write
-jobs:
-  pypi:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v6
-    - uses: astral-sh/setup-uv@v7
-    - run: uv build
-    - uses: pypa/gh-action-pypi-publish@release/v1
-  npm:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v6
-    - uses: actions/setup-node@v6
-      with:
-        node-version: 24
-        registry-url: https://registry.npmjs.org
-    - run: npm publish --provenance --access public
-      env:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

strictcli-0.23.0/.rlsbl/config.json

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

strictcli-0.23.0/.rlsbl/version

@@ -1 +0,0 @@
-0.92.0

strictcli-0.23.0/CHANGELOG.md

@@ -1,52 +0,0 @@
-<!-- Generated by rlsbl from .rlsbl/changes/ — do not edit -->
-
-# Changelog
-
-## 0.23.0
-
-Registration-time ban on bare --force flag name and --no-* prefix
-
-<details>
-<summary>Context</summary>
-
-Flag names 'force' (exact) and names starting with 'no-' are now rejected at registration time. Bare --force encourages agents to bypass guardrails without thinking; qualified names like --force-overwrite make the intent explicit. The no- prefix is reserved for strictcli's auto-generated negation system (--no-flag for negatable bools).
-
-</details>
-
-### Features
-
-- **New.** Registration-time ban on bare --force flag name and --no-* prefix. Flag names starting with no- are reserved for the negation system.
-
-## 0.22.0
-
-### Breaking
-
-- **Breaking.** Bool flags no longer auto-default to false. BoolFlag without explicit Default(false) is now required — user must pass --flag or --no-flag.
-
-### Features
-
-- **New.** Schema dump validates project_id before writing — hard error if existing schema belongs to a different project.
-- **New.** Context type with output methods (Info, Warn, Debug, Error, Emit) for structured handler communication.
-- **New.** Comprehensive sub-project READMEs replacing severely stale documentation.
-
-### Fixes
-
-- **Fix.** TagContract now checks global flags, not just command-level flags.
-
-## 0.21.0
-
-### Features
-
-- **New feature.** Programmatic invocation via `app.call()` and `app.acall()` with `InvokeError` exception for structured error handling.
-- **New feature.** Schema versioning with `schema_version` field, constraint serialization (mutex, CoRequired, Requires, Implies), tag contracts, and arg defaults in `--dump-schema` output.
-- **New feature.** Typed positional args with `type` (str/int/float/bool) and `choices` support, matching the flag type system.
-- **New feature.** Command visibility: `hidden` and `interactive` declarations with help text filtering and schema serialization.
-- **New feature.** First-class config fields with `config_field()` declarations, per-command binding, startup validation, `config init` template generation, and unknown-key rejection.
-- **New feature.** Compound types `list[T]` and `dict[str, T]` on flags and args with projection-specific CLI parsing.
-- **New feature.** Tool export: `json_schema()`, `as_tools()`, `Tool` dataclass, and router tool for AI agent integration.
-- **New feature.** MCP projection via `serve_mcp()` and `--mcp` flag for Model Context Protocol tool serving.
-- **New feature.** Optional `scope` field on check definitions for declarative pre-check context filtering, and `set_scope_adapter()` method on App for registering scope transformation callbacks.
-
-### Fixes
-
-- **Fix.** Validate unknown kwargs and enforce required globals in passthrough invoke path.