roschema 0.1.3__tar.gz → 0.2.0__tar.gz

{roschema-0.1.3 → roschema-0.2.0}/.github/workflows/ci.yml

@@ -22,7 +22,9 @@ jobs:
       - name: Install
         run: uv sync --extra dev --extra bag
       - name: Ruff
-        run: uv run ruff check .
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
       - name: Mypy
         run: uv run mypy --strict src
       - name: Rule docs in sync

{roschema-0.1.3 → roschema-0.2.0}/.github/workflows/release.yml

@@ -20,6 +20,7 @@ jobs:
         run: |
           uv run pytest -q
           uv run ruff check .
+          uv run ruff format --check .
           uv run mypy --strict src
           uv run python -m roschema.rules.gendocs --check
       - name: Tag matches package version

{roschema-0.1.3 → roschema-0.2.0}/CHANGELOG.md

@@ -3,6 +3,45 @@
 The format follows [Keep a Changelog](https://keepachangelog.com/), and the
 project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.2.0] - 2026-11-03
+
+### Added
+
+- `bag-check --level` and `--config`.
+- Git baselines read initialised submodules at their recorded commit, and warn
+  when that commit is not available locally.
+
+### Changed
+
+- `bag-check` reports at the `wire` level by default, since constant and other
+  source-level changes do not stop current code decoding a recording.
+- Package-name targets resolve to the workspace source package before the
+  installed copy, with a warning when the installed copy is used.
+- Adding or removing a sequence bound (`T[]` <-> `T[<=N]`) is reported as a
+  bound change (RS007/RS008) rather than an array-kind change (RS006).
+- RS110 takes the severity of the change it traces back to and ignores
+  suppressed, allowlisted or disabled changes.
+- Configuring a rule's severity no longer reports it outside the selected
+  level; only rules that are off by default (such as RS060) bypass the level.
+- The GitHub Action passes `--level` only when set, so configured levels apply.
+- RS002 is tagged `wire` only, and RSL005 explains why `char` and scalar `byte`
+  are ambiguous instead of calling them deprecated.
+
+### Fixed
+
+- `bag-check` skips schemas recorded without a definition and compares service
+  event schemas (`SRV:` blocks) instead of failing.
+- A same-package type written with its package (`pkg/Type` inside `pkg`) is no
+  longer reported as a type change.
+- Duplicate field or constant names are parse errors, as in rosidl.
+- Unknown configuration keys are configuration errors, with a suggestion.
+- `lint --format json` no longer includes semver advisories.
+- Text output no longer wraps long lines when not writing to a terminal.
+- Files are read and written as UTF-8 regardless of locale.
+- GitHub annotation text is escaped.
+- `wchar` in MCAP IDL schemas is rejected instead of narrowed to `char`.
+- The README's GitHub Action example references an existing ref (`@main`).
+
 ## [0.1.3] - 2026-11-03
 
 ### Added

{roschema-0.1.3 → roschema-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: roschema
-Version: 0.1.3
+Version: 0.2.0
 Summary: Breaking-change detection, linting and formatting for ROS 2 interface definitions
 Project-URL: Homepage, https://github.com/justagist/roschema
 Project-URL: Documentation, https://github.com/justagist/roschema#readme
@@ -173,7 +173,7 @@ roschema fmt  [TARGET] [--check]
 
 `lint` checks a single tree (no baseline). Naming rules follow rosidl: field
 names snake_case (RSL001), constants UPPER_SNAKE (RSL002), interface names
-PascalCase (RSL003); it also flags deprecated `char`/scalar-`byte` (RSL005) and
+PascalCase (RSL003); it also flags ambiguous `char`/scalar-`byte` (RSL005) and
 request/response field shadowing in services (RSL010). RSL004 (missing doc) and
 RSL006 (unbounded) are off by default; enable via `[lint.rules]` or per run with
 `--rules` (e.g. `--rules RSL004=warn --rules RSL001=off`; a bare `--rules RSL004`
@@ -307,9 +307,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0            # needed for the git-ref baseline
-      - uses: justagist/roschema/action@v1
+      - uses: justagist/roschema/action@main
         with:
           against: origin/${{ github.base_ref }}
+          # version: "roschema==0.2.0"   # pin a release for reproducible results
           # level: source
           # deep: "true"
           # exclude: "vendor_msgs* legacy_msgs/msg/Old"
@@ -319,6 +320,10 @@ jobs:
 `roschema.lock`). A lockfile or directory baseline needs no `fetch-depth: 0`
 because it is a plain file in the checkout.
 
+By default the Action installs the latest roschema release, so new rules can
+change results without any change on your side. Uncomment `version` to pin a
+release instead.
+
 ## Rule reference
 
 Every rule, its levels, default severity and rationale is documented in

{roschema-0.1.3 → roschema-0.2.0}/README.md

@@ -139,7 +139,7 @@ roschema fmt  [TARGET] [--check]
 
 `lint` checks a single tree (no baseline). Naming rules follow rosidl: field
 names snake_case (RSL001), constants UPPER_SNAKE (RSL002), interface names
-PascalCase (RSL003); it also flags deprecated `char`/scalar-`byte` (RSL005) and
+PascalCase (RSL003); it also flags ambiguous `char`/scalar-`byte` (RSL005) and
 request/response field shadowing in services (RSL010). RSL004 (missing doc) and
 RSL006 (unbounded) are off by default; enable via `[lint.rules]` or per run with
 `--rules` (e.g. `--rules RSL004=warn --rules RSL001=off`; a bare `--rules RSL004`
@@ -273,9 +273,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0            # needed for the git-ref baseline
-      - uses: justagist/roschema/action@v1
+      - uses: justagist/roschema/action@main
         with:
           against: origin/${{ github.base_ref }}
+          # version: "roschema==0.2.0"   # pin a release for reproducible results
           # level: source
           # deep: "true"
           # exclude: "vendor_msgs* legacy_msgs/msg/Old"
@@ -285,6 +286,10 @@ jobs:
 `roschema.lock`). A lockfile or directory baseline needs no `fetch-depth: 0`
 because it is a plain file in the checkout.
 
+By default the Action installs the latest roschema release, so new rules can
+change results without any change on your side. Uncomment `version` to pin a
+release instead.
+
 ## Rule reference
 
 Every rule, its levels, default severity and rationale is documented in

{roschema-0.1.3 → roschema-0.2.0}/action/action.yml

@@ -12,8 +12,10 @@ inputs:
     description: Baseline -- a git ref, directory, .mcap bag or roschema.lock.
     default: origin/main
   level:
-    description: Reporting level (wire, source, introspection, behavior).
-    default: source
+    description: >-
+      Reporting level (wire, source, introspection, behavior). Empty uses the
+      level configured in roschema.toml, else source.
+    default: ""
   format:
     description: Output format (text, json, github).
     default: github
@@ -26,7 +28,10 @@ inputs:
       whitespace only so patterns reach roschema literally.
     default: ""
   version:
-    description: roschema version/specifier for uvx (e.g. "roschema==0.1.0").
+    description: >-
+      roschema requirement for uvx. Unpinned runs the latest release (refreshed
+      on every run, even with a uv cache); pin it (e.g. "roschema==0.2.0") for
+      reproducible results.
     default: roschema
 
 runs:
@@ -46,8 +51,10 @@ runs:
         set -euo pipefail
         args=(check "$ROSCHEMA_TARGET"
               --against "$ROSCHEMA_AGAINST"
-              --level "$ROSCHEMA_LEVEL"
               --format "$ROSCHEMA_FORMAT")
+        if [ -n "$ROSCHEMA_LEVEL" ]; then
+          args+=(--level "$ROSCHEMA_LEVEL")
+        fi
         if [ "$ROSCHEMA_DEEP" = "true" ]; then
           args+=(--deep)
         fi
@@ -55,4 +62,4 @@ runs:
         for glob in "${excludes[@]}"; do
           args+=(--exclude "$glob")
         done
-        uvx --from "$ROSCHEMA_VERSION" roschema "${args[@]}"
+        uvx --refresh-package roschema --from "$ROSCHEMA_VERSION" roschema "${args[@]}"

{roschema-0.1.3 → roschema-0.2.0}/docs/rules.md

@@ -26,7 +26,7 @@ int32 a
 
 A field was added to an interface section.
 
-- Levels: wire, source
+- Levels: wire
 - Default severity: error
 
 *Rationale:* Appending a field is source-compatible but still changes the CDR wire layout, so a new publisher and an old subscriber cannot interoperate.
@@ -91,12 +91,12 @@ float32 yaw
 
 ### RS006 -- Array kind changed
 
-A field changed between fixed, bounded and unbounded array forms.
+A field changed between scalar, fixed-size array and sequence forms.
 
 - Levels: wire, source
 - Default severity: error
 
-*Rationale:* Fixed, bounded and unbounded arrays use different CDR encodings and generate different container types.
+*Rationale:* A sequence carries a length prefix that a fixed-size array and a scalar do not, so the CDR layout and the generated container type both change. Adding or removing a sequence bound is reported as RS007 or RS008 instead.
 
 ```
 # before
@@ -107,7 +107,7 @@ int32[8] data
 
 ### RS007 -- Bound tightened
 
-A bounded array or string had its capacity reduced.
+A sequence or string gained a bound or had its bound reduced.
 
 - Levels: wire
 - Default severity: error
@@ -123,7 +123,7 @@ string<=16 name
 
 ### RS008 -- Bound loosened
 
-A bounded array or string had its capacity increased.
+A sequence or string lost its bound or had its bound increased.
 
 - Levels: wire
 - Default severity: warn
@@ -239,7 +239,7 @@ int32 b
 
 ### RS110 -- Transitively broken by an embedded type
 
-An interface embeds (directly or through nested types) another interface whose wire layout changed, so it is broken even though its own definition did not change. Reported only with --deep.
+An interface embeds (directly or through nested types) another interface whose wire layout changed, so it is broken even though its own definition did not change. Reported only with --deep, with the severity of the reported change it traces back to; suppressed changes are not followed.
 
 - Levels: wire
 - Default severity: error
@@ -290,11 +290,11 @@ A field has no trailing documentation comment.
 
 ### RSL005 -- Discouraged type
 
-Uses `char`, or a scalar `byte`, both deprecated aliases in ROS 2.
+Uses `char`, or a scalar `byte`, whose generated types are ambiguous.
 
 - Default severity: warn
 
-*Rationale:* ROS 2 deprecated `char` and `byte` as scalar types in favour of `uint8`/`int8`; `byte[]` remains idiomatic for opaque binary data.
+*Rationale:* rosidl generates `char` as `uint8` although the ROS 2 type table lists it as a DDS `char`, and a scalar `byte` becomes a Python `bytes` object rather than an integer; `uint8` states the intent. `byte[]` remains idiomatic for opaque binary data.
 
 ### RSL006 -- Unbounded string or array
 

{roschema-0.1.3 → roschema-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "roschema"
-version = "0.1.3"
+version = "0.2.0"
 description = "Breaking-change detection, linting and formatting for ROS 2 interface definitions"
 readme = "README.md"
 license = "Apache-2.0"
@@ -64,4 +64,6 @@ files = ["src"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "-q"
+# A sourced ROS environment auto-loads its launch testing plugins, which fail to
+# import in a virtualenv without ROS's Python dependencies (e.g. PyYAML).
+addopts = "-q -p no:launch_testing -p no:launch_ros -p no:launch_pytest"

{roschema-0.1.3 → roschema-0.2.0}/src/roschema/cli.py

@@ -6,6 +6,7 @@ import json
 import os
 import posixpath
 from collections.abc import Callable
+from dataclasses import replace
 from pathlib import Path
 from typing import Annotated
 
@@ -23,6 +24,7 @@ from .config import (
 from .deep import transitive_findings
 from .differ import diff_interfaces
 from .discovery import (
+    DiscoveredPackage,
     Resolution,
     apply_exclude,
     resolve_ament,
@@ -34,6 +36,7 @@ from .formatter import format_text
 from .freeze import build_lock
 from .ir import InterfaceFile
 from .loader import load_interfaces
+from .mcap_fs import McapTypeFS
 from .parser import ParseError
 from .report import build_github, build_json, render_lint, render_text
 from .rules import Finding, all_lint_rules, evaluate, lint_interfaces
@@ -44,8 +47,14 @@ app = typer.Typer(
     no_args_is_help=True,
     add_completion=False,
 )
-console = Console()
-err_console = Console(stderr=True)
+# Soft wrapping leaves line breaks to the terminal, so CI logs and pipes (where
+# Rich assumes 80 columns) keep paths and messages on one line.
+console = Console(soft_wrap=True)
+err_console = Console(stderr=True, soft_wrap=True)
+
+# A bag check asks whether current code can still decode the recording, which is
+# a wire question; constant and other source-level changes do not affect it.
+BAG_DEFAULT_LEVEL = "wire"
 
 
 def _version_callback(value: bool) -> None:
@@ -79,7 +88,10 @@ def check(
     ] = None,
     against: Annotated[
         str,
-        typer.Option("--against", help="Baseline: git ref or directory path."),
+        typer.Option(
+            "--against",
+            help="Baseline: git ref, directory, MCAP bag (.mcap) or lockfile (.lock).",
+        ),
     ] = ...,  # type: ignore[assignment]
     fmt: Annotated[
         str, typer.Option("--format", help="Output format: text, json or github.")
@@ -144,6 +156,17 @@ def bag_check(
     fmt: Annotated[
         str, typer.Option("--format", help="Output format: text, json or github.")
     ] = "text",
+    level: Annotated[
+        str | None,
+        typer.Option(
+            "--level",
+            help="Reporting level: wire (default for bags), source, introspection, behavior.",
+        ),
+    ] = None,
+    config_path: Annotated[
+        Path | None,
+        typer.Option("--config", help="Explicit config file (roschema.toml or pyproject.toml)."),
+    ] = None,
     exit_zero: Annotated[
         bool, typer.Option("--exit-zero", help="Exit 0 even when findings exist.")
     ] = False,
@@ -162,6 +185,9 @@ def bag_check(
     if fmt not in ("text", "json", "github"):
         err_console.print(f"[red]error:[/red] unknown format {fmt!r}")
         raise typer.Exit(code=2)
+    if level is not None and level not in LEVEL_BUNDLES:
+        err_console.print(f"[red]error:[/red] unknown level {level!r}")
+        raise typer.Exit(code=2)
     if not bag.endswith(".mcap"):
         err_console.print(f"[red]error:[/red] expected a .mcap bag, got {bag!r}")
         raise typer.Exit(code=2)
@@ -169,15 +195,18 @@ def bag_check(
     excludes = exclude or []
     try:
         old_res = resolve_bag(bag)
+        _note_skipped_schemas(old_res)
         old_ifaces = load_interfaces(old_res.vfs, apply_exclude(old_res.packages, excludes))
-        new_ifaces, new_source = _resolve_current(old_ifaces, targets or [], excludes)
-        config = load_config(Path.cwd(), (), None)
+        new_ifaces, new_source, target_packages = _resolve_current(
+            old_ifaces, targets or [], excludes
+        )
+        config = load_config(Path.cwd(), target_packages, config_path)
     except (VfsError, ParseError, ConfigError) as exc:
         err_console.print(f"[red]error:[/red] {exc}")
         raise typer.Exit(code=2) from exc
 
     findings = finalize_findings(
-        evaluate(diff_interfaces(old_ifaces, new_ifaces)), config, None
+        evaluate(diff_interfaces(old_ifaces, new_ifaces)), config, level, BAG_DEFAULT_LEVEL
     )
     _emit(findings, fmt, new_source, old_res.source)
     _exit_for(findings, exit_zero)
@@ -185,24 +214,46 @@ def bag_check(
 
 def _resolve_current(
     bag_ifaces: dict[str, InterfaceFile], targets: list[str], excludes: list[str]
-) -> tuple[dict[str, InterfaceFile], str]:
+) -> tuple[dict[str, InterfaceFile], str, tuple[DiscoveredPackage, ...]]:
     """Build the current-side interfaces for a bag check.
 
     Starts from the ament index (for the packages the bag references), then
-    overlays any explicit targets so they take precedence.
+    overlays any explicit targets so they take precedence. Also returns the
+    target packages with paths relative to the working directory, so their
+    package configuration can be loaded.
     """
     current: dict[str, InterfaceFile] = {}
+    target_packages: list[DiscoveredPackage] = []
     for package in sorted({key.split("/", 1)[0] for key in bag_ifaces}):
         res = resolve_ament(package)
         if res is not None:
             current.update(load_interfaces(res.vfs, apply_exclude(res.packages, excludes)))
     for target in targets:
-        res = resolve_target(target, include_empty=True)
+        res = _resolve_target(target, include_empty=True)
         replaced = {pkg.name for pkg in res.packages}
         current = {key: iface for key, iface in current.items() if iface.package not in replaced}
         current.update(load_interfaces(res.vfs, apply_exclude(res.packages, excludes)))
+        target_packages = [pkg for pkg in target_packages if pkg.name not in replaced]
+        if isinstance(res.vfs, RealFS):
+            target_packages += [
+                replace(pkg, path=os.path.relpath(res.vfs.root / pkg.path, Path.cwd()))
+                for pkg in res.packages
+            ]
     source = "targets+environment" if targets else "environment (ament index)"
-    return current, source
+    return current, source, tuple(target_packages)
+
+
+def _resolve_target(
+    target: str | None, *, allow_empty_glob: bool = False, include_empty: bool = False
+) -> Resolution:
+    """Resolve a CLI target, warning when a package name resolves to an installed copy."""
+    res = resolve_target(target, allow_empty_glob=allow_empty_glob, include_empty=include_empty)
+    if res.source.startswith("ament:"):
+        err_console.print(
+            f"[yellow]warning:[/yellow] {target!r} is not a source package under the "
+            f"working directory; using the installed copy from {res.source[len('ament:') :]}"
+        )
+    return res
 
 
 def _compute(
@@ -214,10 +265,17 @@ def _compute(
     deep: bool | None = None,
 ) -> tuple[list[Finding], str, str, str]:
     """Resolve both sides, diff and finalize; the shared check pipeline."""
-    new_res = resolve_target(target, allow_empty_glob=True)
+    new_res = _resolve_target(target, allow_empty_glob=True)
     if not isinstance(new_res.vfs, RealFS):
         raise VfsError("target must be a directory or workspace")
     old_res = resolve_old(new_res.vfs.root)
+    _note_skipped_schemas(old_res)
+    if isinstance(old_res.vfs, GitTreeFS):
+        for path in old_res.vfs.missing_submodules:
+            err_console.print(
+                f"[yellow]warning:[/yellow] the baseline commit of submodule {path!r} is "
+                "not available locally, so its packages are not compared"
+            )
     config = load_config(new_res.vfs.root, new_res.packages, config_path)
     excludes = exclude or []
     new_ifaces = load_interfaces(new_res.vfs, apply_exclude(new_res.packages, excludes))
@@ -240,14 +298,25 @@ def _compute(
             raise VfsError(f"target glob {target!r} matched no interface packages on either side")
         old_packages = tuple(p for p in old_packages if p.name in scope)
     old_ifaces = load_interfaces(old_res.vfs, apply_exclude(old_packages, excludes))
-    raw = evaluate(diff_interfaces(old_ifaces, new_ifaces))
+    findings = finalize_findings(evaluate(diff_interfaces(old_ifaces, new_ifaces)), config, level)
     deep_packages = {p.name for p in new_res.packages if config.effective_deep(p.name, deep)}
     if deep_packages:
-        raw = raw + [f for f in transitive_findings(new_ifaces, raw) if f.package in deep_packages]
-    findings = finalize_findings(raw, config, level)
+        transitive = transitive_findings(new_ifaces, findings)
+        findings += finalize_findings(
+            [f for f in transitive if f.package in deep_packages], config, level
+        )
     return findings, new_res.source, old_res.source, prefix
 
 
+def _note_skipped_schemas(res: Resolution) -> None:
+    """Name the bag schemas recorded without a definition, which are not checked."""
+    if isinstance(res.vfs, McapTypeFS) and res.vfs.skipped:
+        err_console.print(
+            f"[dim]note: {len(res.vfs.skipped)} bag schema(s) have no recorded definition "
+            f"and are not checked: {', '.join(res.vfs.skipped)}[/dim]"
+        )
+
+
 def _display_prefix(target_dir: Path) -> str:
     """Repo-root-relative prefix for a real-filesystem target, or ``""``."""
     top = git_toplevel(target_dir)
@@ -315,7 +384,7 @@ def lint(
 
     try:
         overrides = _parse_rule_overrides(rules or [])
-        res = resolve_target(target)
+        res = _resolve_target(target)
         if not isinstance(res.vfs, RealFS):
             raise VfsError("lint target must be a directory or workspace")
         config = load_config(res.vfs.root, res.packages, config_path)
@@ -326,7 +395,7 @@ def lint(
 
     findings = finalize_lint(lint_interfaces(interfaces), config, overrides)
     if fmt == "json":
-        typer.echo(json.dumps(build_json(findings), indent=2))
+        typer.echo(json.dumps(build_json(findings, advisories=False), indent=2))
     elif fmt == "github":
         for line in build_github(findings, _display_prefix(res.vfs.root)):
             typer.echo(line)
@@ -371,7 +440,7 @@ def fmt(
 ) -> None:
     """Canonically format interface files (idempotent, comment-preserving)."""
     try:
-        res = resolve_target(target)
+        res = _resolve_target(target)
         if not isinstance(res.vfs, RealFS):
             raise VfsError("fmt target must be a directory or workspace")
         packages = apply_exclude(res.packages, exclude or [])
@@ -383,7 +452,7 @@ def fmt(
                 if formatted != original:
                     changed.append(ref.path)
                     if not check_only:
-                        (res.vfs.root / ref.path).write_text(formatted)
+                        (res.vfs.root / ref.path).write_text(formatted, encoding="utf-8")
     except (VfsError, ParseError) as exc:
         err_console.print(f"[red]error:[/red] {exc}")
         raise typer.Exit(code=2) from exc
@@ -407,9 +476,9 @@ def freeze(
         str | None,
         typer.Argument(help="Path, package name, or omit for the current workspace."),
     ] = None,
-    output: Annotated[
-        Path, typer.Option("-o", "--output", help="Lockfile path to write.")
-    ] = Path("roschema.lock"),
+    output: Annotated[Path, typer.Option("-o", "--output", help="Lockfile path to write.")] = Path(
+        "roschema.lock"
+    ),
     exclude: Annotated[
         list[str] | None,
         typer.Option("--exclude", help="Glob of packages/interfaces to skip."),
@@ -417,13 +486,13 @@ def freeze(
 ) -> None:
     """Write a roschema.lock baseline (canonical text + sha256 per interface)."""
     try:
-        res = resolve_target(target)
+        res = _resolve_target(target)
         interfaces = load_interfaces(res.vfs, apply_exclude(res.packages, exclude or []))
     except (VfsError, ParseError) as exc:
         err_console.print(f"[red]error:[/red] {exc}")
         raise typer.Exit(code=2) from exc
 
-    output.write_text(build_lock(interfaces, __version__))
+    output.write_text(build_lock(interfaces, __version__), encoding="utf-8")
     console.print(f"wrote {len(interfaces)} interface(s) to {output}")
 
 
@@ -441,7 +510,7 @@ def ls(
 ) -> None:
     """List discovered interface packages and the source they came from."""
     try:
-        resolution = resolve_target(target)
+        resolution = _resolve_target(target)
     except VfsError as exc:
         err_console.print(f"[red]error:[/red] {exc}")
         raise typer.Exit(code=2) from exc
@@ -463,8 +532,7 @@ def _to_json(resolution: Resolution) -> dict[str, object]:
                 "name": pkg.name,
                 "path": pkg.path,
                 "interfaces": [
-                    {"kind": ref.kind, "name": ref.name, "path": ref.path}
-                    for ref in pkg.interfaces
+                    {"kind": ref.kind, "name": ref.name, "path": ref.path} for ref in pkg.interfaces
                 ],
             }
             for pkg in resolution.packages
@@ -484,9 +552,7 @@ def _print_text(resolution: Resolution) -> None:
             console.print(f"  {ref.kind:<7} {ref.name}  [dim]{ref.path}[/dim]")
             total += 1
     plural = "interface" if total == 1 else "interfaces"
-    console.print(
-        f"\n[dim]{len(resolution.packages)} package(s), {total} {plural}[/dim]"
-    )
+    console.print(f"\n[dim]{len(resolution.packages)} package(s), {total} {plural}[/dim]")
 
 
 if __name__ == "__main__":  # pragma: no cover