datex-studio-cli 0.4.8__tar.gz → 0.4.10__tar.gz

{datex_studio_cli-0.4.8 → datex_studio_cli-0.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datex-studio-cli
-Version: 0.4.8
+Version: 0.4.10
 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.8 → datex_studio_cli-0.4.10}/pyproject.toml

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

{datex_studio_cli-0.4.8 → datex_studio_cli-0.4.10}/src/dxs/__init__.py

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

{datex_studio_cli-0.4.8 → datex_studio_cli-0.4.10}/src/dxs/commands/auth.py

@@ -14,6 +14,44 @@ from dxs.utils.responses import list_response, single
 from dxs.utils.restricted import restrict_in_restricted_mode
 
 
+def _format_age(seconds: int) -> str:
+    """Human-readable age from a number of seconds."""
+    if seconds < 60:
+        return f"{seconds} seconds"
+    if seconds < 3600:
+        return f"{seconds // 60} minutes"
+    if seconds < 86400:
+        return f"{seconds // 3600} hours"
+    return f"{seconds // 86400} days"
+
+
+def _refresh_token_info(identity: Any, now: datetime) -> dict[str, Any]:
+    """Describe the identity's refresh token: presence and age.
+
+    Azure does not return a refresh-token expiry, so we surface the age of the
+    stored token (recorded when it was obtained) to help diagnose refresh issues.
+    """
+    if not identity.refresh_token:
+        return {
+            "present": False,
+            "note": "No refresh token stored; a full login is required.",
+        }
+
+    info: dict[str, Any] = {
+        "present": True,
+        "note": "Azure does not expose refresh-token expiry; age shown for reference.",
+    }
+    acquired_at = identity.refresh_token_acquired_at
+    if acquired_at is not None:
+        age_seconds = int((now - acquired_at).total_seconds())
+        info["acquired_at"] = acquired_at.isoformat()
+        info["age_human"] = _format_age(max(age_seconds, 0))
+    else:
+        info["acquired_at"] = None
+        info["age_human"] = "unknown (log in again to start tracking age)"
+    return info
+
+
 @click.group()
 def auth() -> None:
     """Authentication commands.
@@ -398,8 +436,8 @@ def status(ctx: DxsContext) -> None:
     # If primary token is expired, try to refresh it
     if is_expired:
         ctx.log("Primary access token is expired, attempting to refresh...")
-        refreshed_token = cache.try_refresh()
-        if refreshed_token:
+        outcome = cache.try_refresh_detailed()
+        if outcome.access_token:
             ctx.log("Successfully refreshed access token")
             refreshed_identity = cache.get_active_identity()
             if refreshed_identity:
@@ -415,6 +453,9 @@ def status(ctx: DxsContext) -> None:
                         "message": "Authentication token has expired and refresh failed",
                         "account": active_identity.account_username,
                         "expired_at": active_identity.expires_at.isoformat(),
+                        "refresh_error": outcome.error,
+                        "refresh_error_description": outcome.error_description,
+                        "refresh_token": _refresh_token_info(active_identity, now),
                         "suggestion": "Run 'dxs auth login' to re-authenticate",
                     },
                     semantic_key="authentication",
@@ -430,9 +471,14 @@ def status(ctx: DxsContext) -> None:
         else:
             return f"{seconds // 3600} hours"
 
-    # Check all cached tokens for each resource
+    # Check all cached tokens for each resource.
+    # External-tenant identities must be probed against their own tenant authority;
+    # redeeming their refresh token against the default tenant returns invalid_grant.
     settings = get_settings()
-    client = MSALClient()
+    if active_identity.external_entra_id and active_identity.tenant_id:
+        client = MSALClient.for_tenant(active_identity.tenant_id)
+    else:
+        client = MSALClient()
 
     resources = {
         "datex_api": {
@@ -525,6 +571,7 @@ def status(ctx: DxsContext) -> None:
                 "expires_in_seconds": expires_in_seconds,
                 "expires_in_human": format_expiration(expires_in_seconds),
             },
+            "refresh_token": _refresh_token_info(active_identity, now),
         },
         "tokens": tokens_info if tokens_info else None,
     }

{datex_studio_cli-0.4.8 → datex_studio_cli-0.4.10}/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.8 → datex_studio_cli-0.4.10}/src/dxs/commands/studio.py

@@ -109,19 +109,41 @@ def _launch_server(port: int, no_browser: bool, dev: bool, replace: bool = False
     uvicorn.run(app, host="127.0.0.1", port=port, log_level="warning", lifespan="on")
 
 
-def _require_server() -> dict[str, int]:
-    """Read the studio lockfile and return server info, or raise an error.
+def _resolve_server_port(probe_port: int) -> int:
+    """Return the port of a running studio server, preferring the lockfile.
 
-    Returns:
-        dict with ``port`` and ``pid`` keys.
+    Falls back to probing the well-known port so a server started in another
+    shell or session is still found even when this process can't read or trust
+    the lockfile — e.g. a sandboxed Claude Code agent shell on Windows whose
+    PID-liveness check or ``Path.home()`` resolves differently than the user's
+    interactive session (issue #38).
 
     Raises:
-        click.ClickException: If no running studio server is found.
+        click.ClickException: If no running studio server can be located.
     """
     lock = read_studio_lock()
-    if lock is None:
-        raise click.ClickException("No studio server running. Start with: dxs studio")
-    return lock
+    if lock is not None:
+        return int(lock["port"])
+    if _port_in_use(probe_port):
+        return probe_port
+    raise click.ClickException("No studio server running. Start with: dxs studio")
+
+
+def _unreachable_error(subcommand: str, port: int, file: str | None, exc: Exception) -> str:
+    """Build an actionable error for a server that is found but unreachable.
+
+    Distinguishes "no server" (handled in :func:`_resolve_server_port`) from
+    "found but the request failed" — typically a sandboxed agent shell that
+    can't open a loopback connection to the user's server.
+    """
+    arg = f" {file}" if file else ""
+    return (
+        f"Found a studio server on port {port} but couldn't reach it: {exc}\n"
+        "If Studio is running in your own terminal and this is a sandboxed agent "
+        "shell (common on Windows), the agent process may be blocked from the "
+        "local server. Run the command in your own session instead:\n"
+        f"  ! dxs studio {subcommand}{arg}"
+    )
 
 
 @click.group(invoke_without_command=True)
@@ -166,18 +188,24 @@ def studio(ctx: click.Context, port: int, no_browser: bool, dev: bool, replace:
 
 @studio.command("open")
 @click.argument("file", type=click.Path())
-def studio_open(file: str) -> None:
+@click.option(
+    "--port",
+    "-p",
+    type=int,
+    default=5051,
+    help="Port to probe when no studio lockfile is present (default: 5051)",
+)
+def studio_open(file: str, port: int) -> None:
     """Open a report file in the studio design canvas.
 
     FILE is the path to a report file (.rdlx-json) to open.
     """
-    lock = _require_server()
-    port = lock["port"]
+    server_port = _resolve_server_port(port)
     resolved = str(Path(file).resolve())
 
     try:
         resp = httpx.post(
-            f"http://127.0.0.1:{port}/api/design/open",
+            f"http://127.0.0.1:{server_port}/api/design/open",
             json={"path": resolved},
             timeout=10.0,
         )
@@ -190,31 +218,69 @@ def studio_open(file: str) -> None:
             raise click.ClickException(detail)
         resp.raise_for_status()
     except httpx.HTTPError as exc:
-        raise click.ClickException(f"Failed to open file in studio: {exc}") from exc
+        raise click.ClickException(_unreachable_error("open", server_port, file, exc)) from exc
 
     data = resp.json()
     file_path = data.get("path", resolved)
-    click.echo(f"Opened {file_path} in studio (http://127.0.0.1:{port}/design)")
+    click.echo(f"Opened {file_path} in studio (http://127.0.0.1:{server_port}/design)")
 
 
 @studio.command("close")
-def studio_close() -> None:
+@click.option(
+    "--port",
+    "-p",
+    type=int,
+    default=5051,
+    help="Port to probe when no studio lockfile is present (default: 5051)",
+)
+def studio_close(port: int) -> None:
     """Close the current design session in studio."""
-    lock = _require_server()
-    port = lock["port"]
+    server_port = _resolve_server_port(port)
 
     try:
         resp = httpx.post(
-            f"http://127.0.0.1:{port}/api/design/close",
+            f"http://127.0.0.1:{server_port}/api/design/close",
             timeout=10.0,
         )
         resp.raise_for_status()
     except httpx.HTTPError as exc:
-        raise click.ClickException(f"Failed to close design session: {exc}") from exc
+        raise click.ClickException(_unreachable_error("close", server_port, None, exc)) from exc
 
     click.echo("Design session closed")
 
 
+@studio.command("stop")
+@click.option(
+    "--port",
+    "-p",
+    type=int,
+    default=5051,
+    help="Port to probe when no studio lockfile is present (default: 5051)",
+)
+def studio_stop(port: int) -> None:
+    """Stop the studio server tracked by the lockfile.
+
+    Only terminates a server whose PID this CLI recorded in its own lockfile;
+    a process we don't manage is never killed.
+    """
+    lock = read_studio_lock()
+    if lock is None:
+        if _port_in_use(port):
+            raise click.ClickException(
+                f"A server is running on port {port} but it isn't tracked by a "
+                "studio lockfile, so it won't be stopped automatically. Stop it "
+                "from the terminal that launched it."
+            )
+        raise click.ClickException("No studio server running.")
+
+    pid = int(lock["pid"])
+    server_port = int(lock["port"])
+    _terminate_pid(pid)
+    _await_port_free(server_port)
+    remove_studio_lock()
+    click.echo(f"Stopped studio (pid {pid}) on port {server_port}.")
+
+
 @studio.command("status")
 @click.option(
     "--port",

{datex_studio_cli-0.4.8 → datex_studio_cli-0.4.10}/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",