datex-studio-cli 0.4.7__tar.gz → 0.4.9__tar.gz

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datex-studio-cli
-Version: 0.4.7
+Version: 0.4.9
 Summary: CLI for Datex Studio low-code platform, designed for LLM-based AI agents
 Project-URL: Homepage, https://github.com/datex/datex-studio-cli
 Project-URL: Documentation, https://github.com/datex/datex-studio-cli

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datex-studio-cli"
-version = "0.4.7"
+version = "0.4.9"
 description = "CLI for Datex Studio low-code platform, designed for LLM-based AI agents"
 readme = "README.md"
 license = "MIT"

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/src/dxs/__init__.py

@@ -1,4 +1,4 @@
 """Datex Studio CLI - Command-line interface for Datex Studio platform."""
 
-__version__ = "0.4.7"
+__version__ = "0.4.9"
 __app_name__ = "dxs"

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/src/dxs/commands/configuration.py

@@ -397,8 +397,7 @@ def configuration_validate(
         )
     else:
         formatted = [
-            {"message": e.get("message", str(e)) if isinstance(e, dict) else str(e)}
-            for e in errors
+            {"message": e.get("message", str(e)) if isinstance(e, dict) else str(e)} for e in errors
         ]
         ctx.output(list_response(items=formatted, semantic_key="validation_errors"))
 
@@ -443,6 +442,72 @@ def configuration_contexts(
     ctx.output(single(item=response or {}, semantic_key="configuration_contexts"))
 
 
+@configuration.command("nomenclature")
+@click.option("--branch", "-b", type=int, default=None, help="Branch ID (falls back to global -b)")
+@click.option(
+    "--package",
+    "-p",
+    "package",
+    default=None,
+    help="Filter to one package (matches the <Package> segment of the type key).",
+)
+@click.option(
+    "--kind",
+    type=click.Choice(["all", "enum", "interface"]),
+    default="all",
+    show_default=True,
+    help="Filter by kind: enums (have members) or interfaces (no members).",
+)
+@click.option(
+    "--search",
+    "search",
+    default=None,
+    help="Case-insensitive substring match on the fully-qualified type key.",
+)
+@pass_context
+@require_auth
+def configuration_nomenclature(
+    ctx: DxsContext,
+    branch: int | None,
+    package: str | None,
+    kind: str,
+    search: str | None,
+) -> None:
+    """List custom types (interfaces/enums) and enum members on a branch.
+
+    Returns the platform's nomenclature registry: a flat catalog of every
+    `<Package>.<Type>` custom type, with each enum's members in
+    `constantValues` (empty for interfaces). Use it to confirm a type or enum
+    member exists before referencing `$types.<Package>.<Type>` in flow /
+    expression code — lighter than fetching full bodies (`get customtype`) or
+    the designer contexts (`contexts`).
+
+    \b
+    Examples:
+        dxs configuration nomenclature -b 64
+        dxs configuration nomenclature -b 64 --package Cartonization --kind enum
+        dxs configuration nomenclature -b 64 --search e_stage
+    """
+    branch_id = resolve_branch(ctx, branch, "DXS-CFG-010")
+
+    api_client = ApiClient()
+    path = ConfigurationEndpoints.custom_type_nomenclature(branch_id)
+    items: list[Any] = api_client.get(path) or []
+
+    if package:
+        prefix = f"{package.lower()}."
+        items = [i for i in items if str(i.get("key", "")).lower().startswith(prefix)]
+    if kind == "enum":
+        items = [i for i in items if i.get("constantValues")]
+    elif kind == "interface":
+        items = [i for i in items if not i.get("constantValues")]
+    if search:
+        needle = search.lower()
+        items = [i for i in items if needle in str(i.get("key", "")).lower()]
+
+    ctx.output(list_response(items=items, semantic_key="custom_types", branch_id=branch_id))
+
+
 @configuration.command("list")
 @click.argument("config_type")
 @click.option("--branch", "-b", type=int, default=None, help="Branch ID (falls back to global -b)")

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/src/dxs/commands/source.py

@@ -22,6 +22,7 @@ from dxs.core.api import (
     RepoEndpoints,
     SourceControlEndpoints,
     WorkitemEndpoints,
+    diff_references,
     fetch_references,
     fetch_settings,
 )
@@ -29,10 +30,13 @@ from dxs.core.auth import require_auth
 from dxs.core.output.yaml_fmt import LiteralString
 from dxs.core.release_notes import (
     aggregate_contributors,
+    build_repo_index,
     classify_dependencies,
     collect_workitems_batch,
     enrich_workitems_with_devops_data,
     is_sync_commit,
+    resolve_changed_dependencies,
+    resolve_root_org_ids,
 )
 from dxs.utils.errors import ValidationError
 from dxs.utils.responses import list_response, single
@@ -2770,106 +2774,186 @@ def deps_diff(ctx: DxsContext, from_branch: int, to_branch: int) -> None:
     """
     client = ApiClient()
 
-    # Fetch dependencies for both branches in parallel conceptually
     ctx.log(f"Fetching dependencies for branch {from_branch}...")
     from_deps = fetch_references(client, from_branch, direct_only=True)
 
     ctx.log(f"Fetching dependencies for branch {to_branch}...")
     to_deps = fetch_references(client, to_branch, direct_only=True)
 
-    # Normalize to lists
-    if not isinstance(from_deps, list):
-        from_deps = [from_deps] if from_deps else []
-    if not isinstance(to_deps, list):
-        to_deps = [to_deps] if to_deps else []
-
-    # Build lookup maps by referenceName
-    from_by_ref = {d.get("referenceName"): d for d in from_deps}
-    to_by_ref = {d.get("referenceName"): d for d in to_deps}
-
-    # Compute differences
-    added = []
-    removed = []
-    updated = []
-    unchanged_count = 0
-
-    # Find added and updated
-    for ref_name, to_dep in to_by_ref.items():
-        if ref_name not in from_by_ref:
-            # New dependency
-            added.append(
-                {
-                    "referenceName": ref_name,
-                    "name": to_dep.get("name"),
-                    "description": to_dep.get("description"),
-                    "versionName": to_dep.get("versionName"),
-                    "versionId": to_dep.get("marketPlaceApplicationVersionId"),
-                    "applicationId": to_dep.get("applicationId"),
-                    "commitTitle": to_dep.get("commitTitle"),
-                    "isDirect": to_dep.get("isDirect"),
-                }
-            )
-        else:
-            from_dep = from_by_ref[ref_name]
-            from_version_id = from_dep.get("marketPlaceApplicationVersionId")
-            to_version_id = to_dep.get("marketPlaceApplicationVersionId")
+    # Diff by resolved `version` keyed on uniqueIdentifier. (The legacy
+    # marketPlaceApplicationVersionId field no longer exists in the AppConfig
+    # payload, so the previous comparison reported everything as unchanged.)
+    diff = diff_references(from_deps, to_deps)
 
-            if from_version_id != to_version_id:
-                # Updated dependency
-                updated.append(
-                    {
-                        "referenceName": ref_name,
-                        "name": to_dep.get("name"),
-                        "fromVersionId": from_version_id,
-                        "toVersionId": to_version_id,
-                        "fromApplicationId": from_dep.get("applicationId"),
-                        "toApplicationId": to_dep.get("applicationId"),
-                        "fromVersionName": from_dep.get("versionName"),
-                        "toVersionName": to_dep.get("versionName"),
-                        "fromCommitTitle": from_dep.get("commitTitle"),
-                        "toCommitTitle": to_dep.get("commitTitle"),
-                        "isDirect": to_dep.get("isDirect"),
-                    }
-                )
-            else:
-                unchanged_count += 1
+    ctx.output(
+        single(
+            item=diff,
+            semantic_key="dependency_changes",
+            from_branch_id=from_branch,
+            to_branch_id=to_branch,
+        )
+    )
 
-    # Find removed
-    for ref_name, from_dep in from_by_ref.items():
-        if ref_name not in to_by_ref:
-            removed.append(
-                {
-                    "referenceName": ref_name,
-                    "name": from_dep.get("name"),
-                    "description": from_dep.get("description"),
-                    "versionName": from_dep.get("versionName"),
-                    "versionId": from_dep.get("marketPlaceApplicationVersionId"),
-                    "applicationId": from_dep.get("applicationId"),
-                    "isDirect": from_dep.get("isDirect"),
-                }
+
+@source.command("release-tree")
+@click.option(
+    "--from",
+    "from_branch",
+    type=int,
+    required=True,
+    help="Source branch ID (earlier release of the root application)",
+)
+@click.option(
+    "--to",
+    "to_branch",
+    type=int,
+    required=True,
+    help="Target branch ID (later release of the root application)",
+)
+@click.option(
+    "--recursive",
+    is_flag=True,
+    default=False,
+    help="Also walk changed dependencies of changed dependencies (transitive)",
+)
+@click.option(
+    "--max-depth",
+    type=int,
+    default=10,
+    help="Maximum recursion depth when --recursive is set (default: 10)",
+)
+@pass_context
+@require_auth
+def release_tree(
+    ctx: DxsContext,
+    from_branch: int,
+    to_branch: int,
+    recursive: bool,
+    max_depth: int,
+) -> None:
+    """Build the complete changed-dependency worklist between two releases.
+
+    Diffs the root application's dependencies by resolved ``version``, then
+    resolves every changed dependency to its from/to branch IDs (the IDs needed
+    to ``compare`` or drill each package). This is the enumeration step for
+    release notes: one call yields the full list of (package, from_branch,
+    to_branch) tuples to analyze.
+
+    Unlike ``deps-diff`` (which lists version deltas only), this resolves branch
+    IDs. With ``--recursive`` it walks changed dependencies of changed
+    dependencies; for a flat aggregator app (e.g. FootprintManager, which
+    declares every package directly) a single pass is already complete.
+
+    \b
+    Options:
+        --from ID      Earlier release branch ID of the root app
+        --to ID        Later release branch ID of the root app
+        --recursive    Walk transitive changed dependencies
+        --max-depth N  Recursion cap with --recursive (default: 10)
+
+    \b
+    Examples:
+        dxs source release-tree --from 73496 --to 82962
+        dxs source release-tree --from 73496 --to 82962 --recursive
+    """
+    if from_branch == to_branch:
+        raise ValidationError(
+            message="Cannot compare a branch to itself",
+            code="DXS-VAL-002",
+            suggestions=["Provide different --from and --to branch IDs"],
+        )
+
+    client = ApiClient()
+
+    # Root metadata (reference name + version names for the worklist header).
+    from_data = client.get(BranchEndpoints.get(from_branch))
+    to_data = client.get(BranchEndpoints.get(to_branch))
+
+    # The root may be a customer application (e.g. tob-footprint) that references
+    # packages from its own org alongside the shared Datex catalog. Index that
+    # org too, or those packages (e.g. tob-reports) silently fail to resolve.
+    extra_org_ids = resolve_root_org_ids(client, to_data, from_data)
+    root_name = to_data.get("referenceName") or to_data.get("name")
+
+    root = {
+        "reference_name": root_name,
+        "from_version": from_data.get("versionName"),
+        "to_version": to_data.get("versionName"),
+        "from_branch_id": from_branch,
+        "to_branch_id": to_branch,
+        "depth": 0,
+        "is_root": True,
+    }
+
+    # Repo index is built once and reused across all levels.
+    ctx.log("Building repository index...")
+    repo_index = build_repo_index(client, extra_org_ids=extra_org_ids)
+
+    dependencies: list[dict[str, Any]] = []
+    added: list[dict[str, Any]] = []
+    removed: list[dict[str, Any]] = []
+    # visited keyed by the work unit, so the same (package, from, to) is resolved once.
+    visited: set[tuple[Any, Any, Any]] = set()
+
+    # BFS queue of (from_branch_id, to_branch_id, depth) to diff.
+    queue: list[tuple[int, int, int]] = [(from_branch, to_branch, 1)]
+    while queue:
+        cur_from, cur_to, depth = queue.pop(0)
+        ctx.log(f"Diffing dependencies at depth {depth} ({cur_from} -> {cur_to})...")
+        try:
+            from_refs = fetch_references(client, cur_from, direct_only=True)
+            to_refs = fetch_references(client, cur_to, direct_only=True)
+        except Exception:
+            logger.debug("Failed to fetch references for %s/%s", cur_from, cur_to, exc_info=True)
+            continue
+
+        diff = diff_references(from_refs, to_refs)
+        if depth == 1:
+            added = diff["added"]
+            removed = diff["removed"]
+
+        resolved = resolve_changed_dependencies(client, diff["updated"], repo_index=repo_index)
+        for entry in resolved:
+            key = (
+                entry.get("unique_identifier"),
+                entry.get("from_version"),
+                entry.get("to_version"),
             )
+            if key in visited:
+                continue
+            visited.add(key)
+            entry["depth"] = depth
+            dependencies.append(entry)
+
+            if (
+                recursive
+                and depth < max_depth
+                and entry.get("from_branch_id")
+                and entry.get("to_branch_id")
+            ):
+                queue.append((entry["from_branch_id"], entry["to_branch_id"], depth + 1))
 
-    # Sort results by referenceName for consistent output
-    added.sort(key=lambda x: str(x.get("referenceName") or ""))
-    removed.sort(key=lambda x: str(x.get("referenceName") or ""))
-    updated.sort(key=lambda x: str(x.get("referenceName") or ""))
+    dependencies.sort(key=lambda d: (d.get("depth", 0), str(d.get("reference_name") or "")))
+    resolved_ok = sum(1 for d in dependencies if not d.get("resolve_error"))
 
     ctx.output(
         single(
             item={
+                "root": root,
                 "summary": {
+                    "dependencies_total": len(dependencies),
+                    "resolved_ok": resolved_ok,
+                    "resolve_failed": len(dependencies) - resolved_ok,
                     "added_count": len(added),
                     "removed_count": len(removed),
-                    "updated_count": len(updated),
-                    "unchanged_count": unchanged_count,
-                    "from_total": len(from_deps),
-                    "to_total": len(to_deps),
+                    "max_depth_reached": max((d.get("depth", 0) for d in dependencies), default=0),
+                    "recursive": recursive,
                 },
+                "dependencies": dependencies,
                 "added": added,
                 "removed": removed,
-                "updated": updated,
             },
-            semantic_key="dependency_changes",
+            semantic_key="release_tree",
             from_branch_id=from_branch,
             to_branch_id=to_branch,
         )
@@ -3661,54 +3745,47 @@ def compare(
                 filtered.append(entry)
         committed_branches_list = filtered
 
-    # Get dependency changes
+    # Get dependency changes. Diff by resolved `version` keyed on uniqueIdentifier
+    # (the legacy marketPlaceApplicationVersionId field is gone from the AppConfig
+    # payload, which is why the old comparison always reported zero changes).
     dep_changes: dict[str, list[Any]] = {"added": [], "removed": [], "updated": []}
     ctx.log("Comparing dependencies...")
     try:
         from_deps = fetch_references(client, from_branch, direct_only=True)
         to_deps = fetch_references(client, to_branch, direct_only=True)
-
-        # Build lookup by reference name
-        from_by_ref = {d.get("referenceName"): d for d in from_deps}
-        to_by_ref = {d.get("referenceName"): d for d in to_deps}
-
-        # Find added, removed, and updated
-        for ref, dep in to_by_ref.items():
-            if ref not in from_by_ref:
-                dep_changes["added"].append(dep)
-            else:
-                from_dep = from_by_ref[ref]
-                from_dep_ver = from_dep.get("marketPlaceApplicationVersionId")
-                to_dep_ver = dep.get("marketPlaceApplicationVersionId")
-                if from_dep_ver != to_dep_ver:
-                    dep_changes["updated"].append(
-                        {
-                            "reference_name": ref,
-                            "from_branch_id": from_dep.get("applicationId"),
-                            "to_branch_id": dep.get("applicationId"),
-                        }
-                    )
-
-        for ref, dep in from_by_ref.items():
-            if ref not in to_by_ref:
-                dep_changes["removed"].append(dep)
+        diff = diff_references(from_deps, to_deps)
+        dep_changes["added"] = diff["added"]
+        dep_changes["removed"] = diff["removed"]
+        dep_changes["updated"] = diff["updated"]
     except Exception:
         logger.debug("Failed to fetch dependencies for comparison", exc_info=True)
 
-    # Phase 4: Recursive dependency enrichment
+    # Phase 4: Recursive dependency enrichment. The AppConfig payload carries no
+    # branch IDs, so resolve each changed dep's from/to branch IDs before drilling.
     sync_only_dep_count = 0
     if recursive and dep_changes["updated"]:
+        ctx.log("Resolving dependency branch IDs...")
+        # Index the root app's own org too, so a customer app's packages resolve.
+        extra_org_ids = resolve_root_org_ids(client, to_branch_data, from_branch_data)
+        resolved = resolve_changed_dependencies(
+            client, dep_changes["updated"], extra_org_ids=extra_org_ids
+        )
+        drillable = [d for d in resolved if d.get("from_branch_id") and d.get("to_branch_id")]
+        unresolved = [
+            d for d in resolved if not (d.get("from_branch_id") and d.get("to_branch_id"))
+        ]
+
         ctx.log("Recursively comparing updated dependencies...")
-        meaningful_deps, sync_only_deps = classify_dependencies(client, dep_changes["updated"])
+        meaningful_deps, sync_only_deps = classify_dependencies(client, drillable)
         sync_only_dep_count = len(sync_only_deps)
 
         if exclude_sync:
             # When both flags are on, separate sync-only deps
-            dep_changes["updated"] = meaningful_deps
+            dep_changes["updated"] = meaningful_deps + unresolved
             dep_changes["sync_only"] = sync_only_deps
         else:
             # Keep all but mark them
-            dep_changes["updated"] = meaningful_deps + sync_only_deps
+            dep_changes["updated"] = meaningful_deps + sync_only_deps + unresolved
 
     # Phase 2: Collect work item IDs from all committed branches + target branch
     workitem_ids: set[str] = set()

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/src/dxs/core/api/__init__.py

@@ -1,6 +1,7 @@
 """API module for Datex Studio HTTP client and models."""
 
 from dxs.core.api.app_config import (
+    diff_references,
     fetch_app_config,
     fetch_references,
     fetch_settings,
@@ -43,6 +44,7 @@ from dxs.core.api.models import (
 __all__ = [
     "ApiClient",
     # AppConfig helpers
+    "diff_references",
     "fetch_app_config",
     "fetch_references",
     "fetch_settings",

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/src/dxs/core/api/app_config.py

@@ -114,3 +114,93 @@ def fetch_references(
     if direct_only:
         refs = [r for r in refs if r.get("isDirect")]
     return refs
+
+
+def _reference_key(ref: dict[str, Any]) -> str | None:
+    """Stable identity for an AppConfig reference.
+
+    ``uniqueIdentifier`` (e.g. ``datex-inventory``) is the durable cross-branch key;
+    ``referenceName`` is the human label and is used only as a fallback.
+    """
+    return ref.get("uniqueIdentifier") or ref.get("referenceName")
+
+
+def diff_references(
+    from_refs: list[dict[str, Any]],
+    to_refs: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Diff two AppConfig reference lists by their resolved ``version``.
+
+    References are keyed by :func:`_reference_key` (``uniqueIdentifier``) and a
+    dependency counts as *updated* when its ``version`` (the resolved
+    ``versionName`` stamped at publish time, e.g. ``20260531.201800``) differs.
+
+    This is the authoritative dependency-change signal. The legacy
+    ``marketPlaceApplicationVersionId`` field was dropped when settings/references
+    were merged into AppConfig (datex-application-api PR 3754), so any comparison
+    on that field reports everything as unchanged.
+
+    Returns a dict with ``summary`` plus ``added`` / ``removed`` / ``updated``
+    lists. ``updated`` entries carry ``from_version`` and ``to_version``;
+    ``added`` / ``removed`` carry ``version``.
+    """
+    from_by = {k: r for r in from_refs if (k := _reference_key(r))}
+    to_by = {k: r for r in to_refs if (k := _reference_key(r))}
+
+    added: list[dict[str, Any]] = []
+    removed: list[dict[str, Any]] = []
+    updated: list[dict[str, Any]] = []
+    unchanged_count = 0
+
+    for key, to_ref in to_by.items():
+        from_ref = from_by.get(key)
+        if from_ref is None:
+            added.append(
+                {
+                    "reference_name": to_ref.get("referenceName"),
+                    "unique_identifier": to_ref.get("uniqueIdentifier"),
+                    "version": to_ref.get("version"),
+                    "is_direct": to_ref.get("isDirect"),
+                }
+            )
+        elif from_ref.get("version") != to_ref.get("version"):
+            updated.append(
+                {
+                    "reference_name": to_ref.get("referenceName"),
+                    "unique_identifier": to_ref.get("uniqueIdentifier"),
+                    "from_version": from_ref.get("version"),
+                    "to_version": to_ref.get("version"),
+                    "is_direct": to_ref.get("isDirect"),
+                }
+            )
+        else:
+            unchanged_count += 1
+
+    for key, from_ref in from_by.items():
+        if key not in to_by:
+            removed.append(
+                {
+                    "reference_name": from_ref.get("referenceName"),
+                    "unique_identifier": from_ref.get("uniqueIdentifier"),
+                    "version": from_ref.get("version"),
+                    "is_direct": from_ref.get("isDirect"),
+                }
+            )
+
+    added.sort(key=lambda x: str(x.get("reference_name") or ""))
+    removed.sort(key=lambda x: str(x.get("reference_name") or ""))
+    updated.sort(key=lambda x: str(x.get("reference_name") or ""))
+
+    return {
+        "summary": {
+            "added_count": len(added),
+            "removed_count": len(removed),
+            "updated_count": len(updated),
+            "unchanged_count": unchanged_count,
+            "from_total": len(from_refs),
+            "to_total": len(to_refs),
+        },
+        "added": added,
+        "removed": removed,
+        "updated": updated,
+    }

{datex_studio_cli-0.4.7 → datex_studio_cli-0.4.9}/src/dxs/core/api/endpoints.py

@@ -454,6 +454,17 @@ class ConfigurationEndpoints:
         config_type = ConfigurationEndpoints.normalize_type(config_type)
         return f"/applications/{branch_id}/{config_type}configurations/validate"
 
+    @staticmethod
+    def custom_type_nomenclature(branch_id: int) -> str:
+        """Get the custom-type nomenclature registry for a branch.
+
+        Returns a flat catalog of every custom type as ``<Package>.<Type>``,
+        with each enum's members listed in ``constantValues`` (empty for
+        interfaces). This is a customtype-specific route, distinct from the
+        ``{type}configurations`` CRUD surface and the ``/contexts`` route.
+        """
+        return f"/applications/{branch_id}/customtypeconfigurations/nomenclature"
+
     # Singular-to-plural mapping for the configId endpoint.
     # The configId endpoint uses the plural enum name (e.g., "endpoints"),
     # NOT the "{type}configurations" pattern used by CRUD endpoints.