systemlink-cli 1.6.5__tar.gz → 1.7.0__tar.gz

{systemlink_cli-1.6.5 → systemlink_cli-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemlink-cli
-Version: 1.6.5
+Version: 1.7.0
 Summary: SystemLink Integrator CLI - cross-platform CLI for SystemLink workflows and templates.
 License-File: LICENSE
 Author: Fred Visser
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: click (>=7.1.2)
 Requires-Dist: keyring (>=25.6.0,<26.0.0)
+Requires-Dist: packaging (>=21.0)
 Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
 Requires-Dist: questionary (>=2.1.1,<3.0.0)
 Requires-Dist: requests (>=2.32.4,<3.0.0)

{systemlink_cli-1.6.5 → systemlink_cli-1.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "systemlink-cli"
-version = "1.6.5"
+version = "1.7.0"
 description = "SystemLink Integrator CLI - cross-platform CLI for SystemLink workflows and templates."
 authors = ["Fred Visser <fred.visser@emerson.com>"]
 packages = [{ include = "slcli" }]
@@ -35,6 +35,7 @@ truststore = ">=0.9,<0.11"
 watchdog = "^6.0.0"
 pyyaml = "^6.0.3"
 questionary = "^2.1.1"
+packaging = ">=21.0"
 rich = ">=13.7,<15"
 rich-click = ">=1.8,<2"
 

{systemlink_cli-1.6.5 → systemlink_cli-1.7.0}/slcli/_version.py

@@ -1,4 +1,4 @@
 """Version information for slcli."""
 
 # This file is auto-generated. Do not edit manually.
-__version__ = "1.6.5"
+__version__ = "1.7.0"

{systemlink_cli-1.6.5 → systemlink_cli-1.7.0}/slcli/skills/slcli/SKILL.md

@@ -227,6 +227,15 @@ slcli system report --type [SOFTWARE|HARDWARE] -o FILE  # Generate CSV report
 slcli system update <SYSTEM_ID> [OPTIONS]            # Update system metadata
 slcli system remove <SYSTEM_ID>                      # Remove a system
 
+# Compare two systems (by ID or alias)
+slcli system compare <SYSTEM_A> <SYSTEM_B> [-f json]
+# Compares installed software (packages, versions) and connected assets
+# (model, vendor, slot number). Accepts system IDs or alias names.
+# Output sections:
+#   Software: packages unique to each system, version differences
+#   Assets:   assets unique to each system, count mismatches, slot differences
+# Assets are matched by (modelName, vendorName) identity.
+
 # System jobs
 slcli system job list [OPTIONS]
 slcli system job get <JOB_ID>
@@ -249,6 +258,7 @@ slcli tag delete <TAG_PATH>                         # Delete a tag
 ### routine — Event-action and notebook routine management
 
 Two API versions are supported:
+
 - **v2** (default): General event-action routines — monitor tags, work-item changes, and more; trigger alarms, emails, or notebook executions.
 - **v1**: Notebook-execution routines with SCHEDULED or TRIGGERED types.
 
@@ -580,7 +590,7 @@ slcli customfield edit [--directory DIR]                 # Interactively edit +
 ### template — Test plan template management
 
 > **Note:** Work item templates are managed separately via `slcli workitem template`.
-> The `slcli template` command manages test plan *configuration* templates used
+> The `slcli template` command manages test plan _configuration_ templates used
 > when provisioning new test plan instances.
 
 ```bash
@@ -641,6 +651,7 @@ slcli workitem workflow preview [--file PATH] [--id WORKFLOW_ID] [--html] [--no-
 ```
 
 **Create work item options:**
+
 ```bash
 slcli workitem create \
   --name "Battery Cycle Test" \
@@ -696,11 +707,13 @@ slcli skill install --skill [slcli|systemlink-webapp|all] --client [agents|claud
 ```
 
 Client paths:
+
 - `agents` — personal: `~/.agents/skills/`, project: `.agents/skills/` (most agents)
 - `claude` — personal: `~/.claude/skills/`, project: `.claude/skills/`
 - `all` — install to both the `agents` and `claude` locations for the selected scope
 
 Notes:
+
 - `agents` is the default client in interactive mode.
 - `webapp init` installs project-scoped skills into `.agents/skills/` by default.
 

{systemlink_cli-1.6.5 → systemlink_cli-1.7.0}/slcli/system_click.py

@@ -13,6 +13,7 @@ import re
 import shutil
 import sys
 from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import quote_plus
 
 import click
 import questionary
@@ -775,6 +776,7 @@ def _fetch_assets_for_system(system_id: str, take: int) -> Tuple[List[Dict[str,
         "projection": (
             "new(id,name,modelName,modelNumber,vendorName,vendorNumber,serialNumber,"
             "workspace,properties,keywords,location.minionId,location.parent,"
+            "location.slotNumber,"
             "location.physicalLocation,location.state.assetPresence,"
             "location.state.systemConnection,discoveryType,supportsSelfTest,"
             "supportsSelfCalibration,supportsReset,supportsExternalCalibration,"
@@ -1180,6 +1182,396 @@ def _get_job_display_fields(job: Dict[str, Any]) -> Dict[str, str]:
 # ==================================================================
 
 
+def _resolve_system(identifier: str) -> Dict[str, Any]:
+    """Resolve a system by ID or alias.
+
+    First attempts a direct ID lookup. If that fails, queries by alias.
+
+    Args:
+        identifier: System minion ID or alias.
+
+    Returns:
+        System data dictionary.
+
+    Raises:
+        SystemExit: If the system cannot be found or an API error occurs.
+    """
+    import requests as _requests
+
+    # Try direct ID lookup first
+    try:
+        encoded_identifier = quote_plus(identifier)
+        url = f"{_get_sysmgmt_base_url()}/systems?id={encoded_identifier}"
+        resp = make_api_request("GET", url, handle_errors=False)
+        resp.raise_for_status()
+        data = resp.json()
+        if isinstance(data, list) and data:
+            return data[0]
+        if isinstance(data, dict) and data.get("id"):
+            return data
+    except _requests.HTTPError as exc:
+        if exc.response is not None and exc.response.status_code == 404:
+            pass
+        else:
+            handle_api_error(exc)
+    except _requests.RequestException as exc:
+        handle_api_error(exc)
+
+    # Fall back to alias search
+    escaped = _escape_filter_value(identifier)
+    query_url = f"{_get_sysmgmt_base_url()}/query-systems"
+    payload: Dict[str, Any] = {
+        "filter": f'alias = "{escaped}"',
+        "take": 2,
+    }
+    try:
+        resp = make_api_request("POST", query_url, payload=payload)
+        data = resp.json()
+        systems = _parse_systems_response(data)
+        if len(systems) == 1:
+            return systems[0]
+        if len(systems) > 1:
+            click.echo(
+                f"✗ Multiple systems match alias '{identifier}'. Use the system ID instead.",
+                err=True,
+            )
+            sys.exit(ExitCodes.INVALID_INPUT)
+    except SystemExit:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        handle_api_error(exc)
+
+    click.echo(f"✗ System not found: {identifier}", err=True)
+    sys.exit(ExitCodes.NOT_FOUND)
+
+
+def _get_packages(system: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+    """Extract the packages dictionary from a system record.
+
+    Args:
+        system: System data dictionary.
+
+    Returns:
+        Mapping of package name to package info.
+    """
+    packages = system.get("packages")
+    if isinstance(packages, dict):
+        pkg_data = packages.get("data")
+        if isinstance(pkg_data, dict):
+            return pkg_data
+    return {}
+
+
+def _compare_packages(
+    pkgs_a: Dict[str, Dict[str, Any]],
+    pkgs_b: Dict[str, Dict[str, Any]],
+    alias_a: str,
+    alias_b: str,
+    format_output: str,
+) -> Dict[str, Any]:
+    """Compare software packages between two systems.
+
+    Args:
+        pkgs_a: Packages from system A.
+        pkgs_b: Packages from system B.
+        alias_a: Display name for system A.
+        alias_b: Display name for system B.
+        format_output: Output format (table or json).
+
+    Returns:
+        Comparison result dictionary for JSON output.
+    """
+    all_keys = sorted(set(pkgs_a.keys()) | set(pkgs_b.keys()))
+    only_a: List[str] = []
+    only_b: List[str] = []
+    version_diffs: List[Dict[str, str]] = []
+    matching: List[str] = []
+
+    def _normalize_package_entry(entry: Any, key: str) -> Dict[str, str]:
+        """Normalize a package entry to a dict shape for safe comparison."""
+        if isinstance(entry, dict):
+            displayname = entry.get("displayname") or key
+            version = entry.get("version") or ""
+            displayversion = entry.get("displayversion") or ""
+            return {
+                "displayname": str(displayname),
+                "version": str(version),
+                "displayversion": str(displayversion),
+            }
+
+        if isinstance(entry, str):
+            return {
+                "displayname": key,
+                "version": entry,
+                "displayversion": entry,
+            }
+
+        if entry is None:
+            normalized_value = ""
+        else:
+            normalized_value = str(entry)
+
+        return {
+            "displayname": key,
+            "version": normalized_value,
+            "displayversion": normalized_value,
+        }
+
+    for key in all_keys:
+        in_a = key in pkgs_a
+        in_b = key in pkgs_b
+        if in_a and not in_b:
+            only_a.append(key)
+        elif in_b and not in_a:
+            only_b.append(key)
+        else:
+            pkg_a = _normalize_package_entry(pkgs_a[key], key)
+            pkg_b = _normalize_package_entry(pkgs_b[key], key)
+            ver_a = pkg_a.get("version") or pkg_a.get("displayversion") or ""
+            ver_b = pkg_b.get("version") or pkg_b.get("displayversion") or ""
+            if ver_a != ver_b:
+                name = pkg_a.get("displayname") or pkg_b.get("displayname") or key
+                version_diffs.append({"package": name, "version_a": ver_a, "version_b": ver_b})
+            else:
+                matching.append(key)
+
+    result: Dict[str, Any] = {
+        "only_system_a": only_a,
+        "only_system_b": only_b,
+        "version_differences": version_diffs,
+        "matching_count": len(matching),
+    }
+
+    if format_output.lower() != "json":
+        click.echo("\n  Software Comparison")
+        click.echo("  " + "─" * 60)
+
+        if not only_a and not only_b and not version_diffs:
+            click.echo("  ✓ Software is identical across both systems.")
+        else:
+            if only_a:
+                click.echo(f"\n  Only on {alias_a}:")
+                for key in only_a:
+                    pkg_a = _normalize_package_entry(pkgs_a[key], key)
+                    name = pkg_a.get("displayname") or key
+                    ver = pkg_a.get("displayversion") or pkg_a.get("version") or ""
+                    click.echo(f"    + {name}  ({ver})" if ver else f"    + {name}")
+
+            if only_b:
+                click.echo(f"\n  Only on {alias_b}:")
+                for key in only_b:
+                    pkg_b = _normalize_package_entry(pkgs_b[key], key)
+                    name = pkg_b.get("displayname") or key
+                    ver = pkg_b.get("displayversion") or pkg_b.get("version") or ""
+                    click.echo(f"    + {name}  ({ver})" if ver else f"    + {name}")
+
+            if version_diffs:
+                click.echo("\n  Version Differences:")
+                for diff in version_diffs:
+                    ver_a = diff["version_a"]
+                    ver_b = diff["version_b"]
+                    # Determine which version is newer
+                    try:
+                        from packaging.version import Version
+
+                        newer_is_a = Version(ver_a) > Version(ver_b)
+                    except Exception:
+                        newer_is_a = ver_a > ver_b
+                    if newer_is_a:
+                        mark_a, mark_b = "+", "-"
+                    else:
+                        mark_a, mark_b = "-", "+"
+                    click.echo(f"    {diff['package']}:")
+                    click.echo(f"      {mark_a} {alias_a}: {ver_a}")
+                    click.echo(f"      {mark_b} {alias_b}: {ver_b}")
+
+        click.echo(
+            f"\n  Summary: {len(matching)} matching, "
+            f"{len(only_a)} only on {alias_a}, "
+            f"{len(only_b)} only on {alias_b}, "
+            f"{len(version_diffs)} version differences"
+        )
+
+    return result
+
+
+def _compare_assets(
+    assets_a: List[Dict[str, Any]],
+    assets_b: List[Dict[str, Any]],
+    alias_a: str,
+    alias_b: str,
+    format_output: str,
+) -> Dict[str, Any]:
+    """Compare assets connected to two systems.
+
+    Assets are considered equivalent if they share the same model and vendor.
+    A mismatch in the set of (model, vendor) pairs is listed under only_system_a
+    or only_system_b.  Matching assets in different slots are listed under
+    slot_differences.
+
+    Args:
+        assets_a: Assets connected to system A.
+        assets_b: Assets connected to system B.
+        alias_a: Display name for system A.
+        alias_b: Display name for system B.
+        format_output: Output format (table or json).
+
+    Returns:
+        Comparison result dictionary for JSON output.
+    """
+
+    def _asset_identity(asset: Dict[str, Any]) -> Tuple[str, str]:
+        return (asset.get("modelName") or "", asset.get("vendorName") or "")
+
+    def _asset_slot(asset: Dict[str, Any]) -> str:
+        loc = asset.get("location")
+        if isinstance(loc, dict):
+            slot = loc.get("slotNumber")
+            if slot is not None:
+                return str(slot)
+        return ""
+
+    # Group assets by (model, vendor) identity
+    groups_a: Dict[Tuple[str, str], List[Dict[str, Any]]] = {}
+    for a in assets_a:
+        groups_a.setdefault(_asset_identity(a), []).append(a)
+
+    groups_b: Dict[Tuple[str, str], List[Dict[str, Any]]] = {}
+    for b in assets_b:
+        groups_b.setdefault(_asset_identity(b), []).append(b)
+
+    all_identities = sorted(set(groups_a.keys()) | set(groups_b.keys()))
+
+    only_a: List[Dict[str, Any]] = []
+    only_b: List[Dict[str, Any]] = []
+    count_mismatches: List[Dict[str, Any]] = []
+    slot_diffs: List[Dict[str, Any]] = []
+    matching: List[Dict[str, str]] = []
+
+    def _asset_slot_sort_key(asset: Dict[str, Any]) -> Tuple[int, int, str, str]:
+        """Build a deterministic sort key that compares numeric slot values numerically."""
+        slot = _asset_slot(asset).strip()
+        if slot.isdigit():
+            return (0, int(slot), "", "")
+
+        stable_fallback = json.dumps(asset, sort_keys=True, default=str)
+        return (1, sys.maxsize, slot, stable_fallback)
+
+    for identity in all_identities:
+        model, vendor = identity
+        in_a = groups_a.get(identity, [])
+        in_b = groups_b.get(identity, [])
+
+        count_a = len(in_a)
+        count_b = len(in_b)
+
+        if count_a and not count_b:
+            only_a.append({"model": model, "vendor": vendor, "count": count_a})
+        elif count_b and not count_a:
+            only_b.append({"model": model, "vendor": vendor, "count": count_b})
+        elif count_a != count_b:
+            count_mismatches.append(
+                {
+                    "model": model,
+                    "vendor": vendor,
+                    "count_system_a": count_a,
+                    "count_system_b": count_b,
+                }
+            )
+        else:
+            # Same count — compare slots pairwise (sorted by numeric slot when possible)
+            sorted_a = sorted(in_a, key=_asset_slot_sort_key)
+            sorted_b = sorted(in_b, key=_asset_slot_sort_key)
+            all_match = True
+            for a_item, b_item in zip(sorted_a, sorted_b):
+                slot_a = _asset_slot(a_item)
+                slot_b = _asset_slot(b_item)
+                if slot_a != slot_b:
+                    all_match = False
+                    slot_diffs.append(
+                        {
+                            "model": model,
+                            "vendor": vendor,
+                            "slot_a": slot_a,
+                            "slot_b": slot_b,
+                        }
+                    )
+            if all_match:
+                matching.append({"model": model, "vendor": vendor})
+
+    result: Dict[str, Any] = {
+        "only_system_a": only_a,
+        "only_system_b": only_b,
+        "count_mismatches": count_mismatches,
+        "slot_differences": slot_diffs,
+        "matching_count": len(matching),
+    }
+
+    if format_output.lower() != "json":
+        click.echo("\n  Asset Comparison")
+        click.echo("  " + "─" * 60)
+
+        has_diffs = only_a or only_b or count_mismatches or slot_diffs
+        if not has_diffs:
+            click.echo("  ✓ Assets are identical across both systems.")
+        else:
+            if only_a:
+                click.echo(f"\n  Only on {alias_a}:")
+                for item in only_a:
+                    label = (
+                        f"{item['model']} ({item['vendor']})"
+                        if item["vendor"]
+                        else item["model"] or "(unknown)"
+                    )
+                    suffix = f"  x{item['count']}" if item["count"] > 1 else ""
+                    click.echo(f"    + {label}{suffix}")
+
+            if only_b:
+                click.echo(f"\n  Only on {alias_b}:")
+                for item in only_b:
+                    label = (
+                        f"{item['model']} ({item['vendor']})"
+                        if item["vendor"]
+                        else item["model"] or "(unknown)"
+                    )
+                    suffix = f"  x{item['count']}" if item["count"] > 1 else ""
+                    click.echo(f"    + {label}{suffix}")
+
+            if count_mismatches:
+                click.echo("\n  Count Mismatches:")
+                for item in count_mismatches:
+                    label = (
+                        f"{item['model']} ({item['vendor']})"
+                        if item["vendor"]
+                        else item["model"] or "(unknown)"
+                    )
+                    click.echo(f"    {label}:")
+                    click.echo(f"      {alias_a}: {item['count_system_a']} installed")
+                    click.echo(f"      {alias_b}: {item['count_system_b']} installed")
+
+            if slot_diffs:
+                click.echo("\n  Slot Differences:")
+                for item in slot_diffs:
+                    label = (
+                        f"{item['model']} ({item['vendor']})"
+                        if item["vendor"]
+                        else item["model"] or "(unknown)"
+                    )
+                    click.echo(f"    {label}:")
+                    click.echo(f"      {alias_a}: slot {item['slot_a'] or '(none)'}")
+                    click.echo(f"      {alias_b}: slot {item['slot_b'] or '(none)'}")
+
+        click.echo(
+            f"\n  Summary: {len(matching)} matching, "
+            f"{len(only_a)} only on {alias_a}, "
+            f"{len(only_b)} only on {alias_b}, "
+            f"{len(count_mismatches)} count mismatches, "
+            f"{len(slot_diffs)} slot differences"
+        )
+
+    return result
+
+
 def register_system_commands(cli: Any) -> None:
     """Register the 'system' command group and its subcommands.
 
@@ -2219,3 +2611,94 @@ def register_system_commands(cli: Any) -> None:
 
         except Exception as exc:  # noqa: BLE001
             handle_api_error(exc)
+
+    @system.command(name="compare")
+    @click.argument("system_a")
+    @click.argument("system_b")
+    @click.option(
+        "--format",
+        "-f",
+        type=click.Choice(["table", "json"]),
+        default="table",
+        show_default=True,
+        help="Output format.",
+    )
+    def compare_systems(
+        system_a: str,
+        system_b: str,
+        format: str,
+    ) -> None:
+        """Compare two systems by software and connected assets.
+
+        SYSTEM_A and SYSTEM_B are system IDs or aliases. The command
+        fetches installed software and connected assets for each system,
+        then highlights differences in packages, versions, slot numbers,
+        models, and vendors.
+        """
+        format_output = validate_output_format(format)
+
+        try:
+            # Resolve both systems (by ID or alias)
+            sys_a = _resolve_system(system_a)
+            sys_b = _resolve_system(system_b)
+
+            id_a = sys_a.get("id", system_a)
+            id_b = sys_b.get("id", system_b)
+            alias_a = sys_a.get("alias") or id_a
+            alias_b = sys_b.get("alias") or id_b
+
+            # Fetch assets for both systems in parallel. The current helper
+            # supports a take limit, so explicitly guard against silently
+            # comparing truncated results when a system has more assets than
+            # the fetch cap.
+            asset_fetch_limit = 1000
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future_assets_a = executor.submit(_fetch_assets_for_system, id_a, asset_fetch_limit)
+                future_assets_b = executor.submit(_fetch_assets_for_system, id_b, asset_fetch_limit)
+
+            assets_a, total_assets_a = future_assets_a.result()
+            assets_b, total_assets_b = future_assets_b.result()
+
+            truncated_systems: List[str] = []
+            if total_assets_a > asset_fetch_limit:
+                truncated_systems.append(
+                    f"{alias_a} ({total_assets_a} assets, limit {asset_fetch_limit})"
+                )
+            if total_assets_b > asset_fetch_limit:
+                truncated_systems.append(
+                    f"{alias_b} ({total_assets_b} assets, limit {asset_fetch_limit})"
+                )
+
+            if truncated_systems:
+                click.echo(
+                    "✗ Error: system comparison would be incomplete because "
+                    "asset retrieval is limited to the first "
+                    f"{asset_fetch_limit} assets. Affected system(s): "
+                    + ", ".join(truncated_systems),
+                    err=True,
+                )
+                sys.exit(ExitCodes.GENERAL_ERROR)
+
+            # Extract packages
+            pkgs_a = _get_packages(sys_a)
+            pkgs_b = _get_packages(sys_b)
+
+            if format_output.lower() == "json":
+                output: Dict[str, Any] = {
+                    "system_a": {"id": id_a, "alias": alias_a},
+                    "system_b": {"id": id_b, "alias": alias_b},
+                    "software": _compare_packages(pkgs_a, pkgs_b, alias_a, alias_b, format_output),
+                    "assets": _compare_assets(assets_a, assets_b, alias_a, alias_b, format_output),
+                }
+                click.echo(json.dumps(output, indent=2))
+            else:
+                click.echo(f"\n  Comparing: {alias_a}  ↔  {alias_b}")
+                click.echo("  " + "═" * 60)
+                _compare_packages(pkgs_a, pkgs_b, alias_a, alias_b, format_output)
+                _compare_assets(assets_a, assets_b, alias_a, alias_b, format_output)
+                click.echo()
+
+        except SystemExit:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            handle_api_error(exc)