datex-studio-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{datex_studio_cli-0.5.0 → datex_studio_cli-0.5.2}/.github/workflows/ci.yml

@@ -59,3 +59,32 @@ jobs:
       - run: uv run ruff check quartermaster
       - run: uv run --package quartermaster mypy quartermaster/src/quartermaster
       - run: uv run --package quartermaster pytest quartermaster/tests -q
+
+  # The artifact nobody was looking at. 0.5.0 and 0.5.1 both shipped without
+  # dxs.core.quartermaster and dxs.core.skills, and 0.5.1 could not run
+  # `dxs --version` at all -- while this suite was fully green, because tests
+  # import from the source tree and never open the wheel. release.yml calls
+  # this workflow, so a broken artifact now blocks the release too.
+  package:
+    runs-on: arc-dxs
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.0.1
+        with:
+          enable-cache: true
+          cache-suffix: package
+          download-from-astral-mirror: false
+      - run: uv python install 3.13
+      - run: uv build
+      - name: Every package under src/ must be in the wheel
+        run: uv run python scripts/check_wheel_completeness.py
+      - name: The built wheel must actually run
+        run: |
+          # A clean venv, not the workspace: importing from the source tree is
+          # exactly what hid this. Resolve deps from the index like a user does.
+          uv venv /tmp/smoke
+          uv pip install --python /tmp/smoke/bin/python dist/*.whl
+          /tmp/smoke/bin/dxs --version
+          /tmp/smoke/bin/dxs skills --help > /dev/null
+          /tmp/smoke/bin/python -c "import dxs.core.quartermaster, dxs.core.skills"

{datex_studio_cli-0.5.0 → datex_studio_cli-0.5.2}/.gitignore

@@ -105,3 +105,9 @@ test-preview.svg
 
 # Live auth matrix config (real accounts)
 tests/live/accounts.local.json
+
+# Project-scope `dxs skills` install artifacts (.claude/skills is above).
+# Canonical copies, the codex symlink tree, and the install record.
+.agents/
+.codex/
+skills-lock.json

{datex_studio_cli-0.5.0 → datex_studio_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: datex-studio-cli
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → datex_studio_cli-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datex-studio-cli"
-version = "0.5.0"
+version = "0.5.2"
 description = "CLI for Datex Studio low-code platform, designed for LLM-based AI agents"
 readme = "README.md"
 license = "MIT"
@@ -94,7 +94,7 @@ exclude = [
     "documentation/",
     "exploration/",
     "exclude/",
-    "skills/",
+    "/skills/",
     "tests/",
     "publish.sh",
     "*.analysis.md",
@@ -102,7 +102,7 @@ exclude = [
     "uv.lock",
     "src/dxs/web/frontend/",
     "example-reports/",
-    "quartermaster/",
+    "/quartermaster/",
 ]
 
 [tool.uv.workspace]
@@ -149,6 +149,10 @@ ignore_missing_imports = true
 module = ["fastapi.*", "uvicorn.*"]
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+module = ["pyodbc"]
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
@@ -160,6 +164,7 @@ markers = [
     "real_auth_state: exercise real auth state (no injected DXS_ACCESS_TOKEN; the variable is scrubbed)",
     "telemetry_live: run without the suite-wide DXS_TELEMETRY=0 kill-switch",
     "live_auth: sign in against real Entra tenants (opt-in; needs DXS_LIVE_AUTH=1 + a human)",
+    "mssql: integration tests against a throwaway SQL Server container (opt-in; needs DXS_MSSQL_TEST=1)",
 ]
 
 [tool.coverage.run]

datex_studio_cli-0.5.2/scripts/check_wheel_completeness.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+"""Assert the built wheel carries every package that exists under src/dxs.
+
+Versions 0.5.0 and 0.5.1 both shipped without ``dxs.core.quartermaster`` and
+``dxs.core.skills``. The sdist exclude list named ``skills/`` and
+``quartermaster/`` to drop the top-level directories of those names; hatchling
+matches an unanchored pattern at any depth, so it dropped the nested packages
+too, and ``uv build`` builds the wheel from the sdist it just made. 0.5.1 could
+not even run ``dxs --version``.
+
+A full green suite said nothing about any of it: tests import from the source
+tree and never open the artifact. This looks at the artifact.
+
+Usage: check_wheel_completeness.py [dist_dir]
+"""
+
+from __future__ import annotations
+
+import sys
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = ROOT / "src"
+
+
+def main() -> int:
+    dist = Path(sys.argv[1]) if len(sys.argv) > 1 else ROOT / "dist"
+    wheels = sorted(dist.glob("*.whl"))
+    if not wheels:
+        print(f"no wheel in {dist} — run `uv build` first", file=sys.stderr)
+        return 1
+    wheel = wheels[-1]
+
+    # Every directory holding an __init__.py is a package that must ship.
+    expected = {
+        p.parent.relative_to(SRC).as_posix() for p in SRC.rglob("__init__.py")
+        if "__pycache__" not in p.parts
+    }
+    names = zipfile.ZipFile(wheel).namelist()
+    shipped = {n.rsplit("/", 1)[0] for n in names if n.endswith("/__init__.py")}
+
+    missing = sorted(expected - shipped)
+    if missing:
+        print(f"{wheel.name} is missing {len(missing)} package(s) present in src/:",
+              file=sys.stderr)
+        for m in missing:
+            print(f"  {m}", file=sys.stderr)
+        print("\nUsually an unanchored exclude pattern in pyproject.toml matching a "
+              "nested path — anchor it with a leading slash.", file=sys.stderr)
+        return 1
+
+    print(f"{wheel.name}: all {len(expected)} packages present")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

datex_studio_cli-0.5.2/scripts/datadog_errors.py

@@ -0,0 +1,275 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["httpx", "python-dotenv"]
+# ///
+"""Pull recent CLI error events from Datadog Logs for investigation.
+
+Queries the Datadog Logs Search API for ``service:dxs-cli status:error`` (the
+telemetry forwarder's shape — see docs/telemetry-datadog-mapping.md) and prints
+either a summary grouped by command + error code, or the raw events.
+
+Credentials come from the project ``.env``: DATADOG_API_KEY, DATADOG_APP_KEY,
+DATADOG_SITE (e.g. ``us3.datadoghq.com``).
+
+Usage:
+    uv run scripts/datadog_errors.py                          # last 24h, summary
+    uv run scripts/datadog_errors.py --since 7d               # last 7 days
+    uv run scripts/datadog_errors.py --since 7d --list        # one line per event
+    uv run scripts/datadog_errors.py --code DXS-API-001 --detail   # full stacks
+    uv run scripts/datadog_errors.py --command source --version 0.5.0 -f json
+    uv run scripts/datadog_errors.py -q 'usr.email:*@datexcorp.com'  # extra filter
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+from collections import Counter, defaultdict
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+SUMMARY_FIELDS = (
+    "ts",
+    "command",
+    "error_code",
+    "error_class",
+    "error_message",
+    "cli_version",
+    "api_target",
+    "env",
+    "usr_email",
+    "org",
+    "os",
+)
+
+
+def parse_since(value: str) -> timedelta:
+    m = re.fullmatch(r"(\d+)([mhd])", value.strip())
+    if not m:
+        raise argparse.ArgumentTypeError("expected like 30m, 6h, 7d")
+    n, unit = int(m.group(1)), m.group(2)
+    return timedelta(**{{"m": "minutes", "h": "hours", "d": "days"}[unit]: n})
+
+
+def build_query(args: argparse.Namespace) -> str:
+    parts = [f"service:{args.service}", "status:error"]
+    if args.env:
+        parts.append(f"env:{args.env}")
+    if args.api_target:
+        parts.append(f"@api_target:{args.api_target}")
+    if args.code:
+        parts.append(f"@error_code:{args.code}")
+    if args.command:
+        parts.append(f'@command:"{args.command}"')
+    if args.version:
+        parts.append(f"@version:{args.version}")
+    if args.query:
+        parts.append(f"({args.query})")
+    return " ".join(parts)
+
+
+def fetch_events(
+    site: str, api_key: str, app_key: str, query: str, since: timedelta, limit: int
+) -> list[dict[str, Any]]:
+    import httpx
+
+    now = datetime.now(timezone.utc)
+    body: dict[str, Any] = {
+        "filter": {
+            "query": query,
+            "from": (now - since).isoformat(),
+            "to": now.isoformat(),
+        },
+        "sort": "-timestamp",
+        "page": {"limit": min(limit, 1000)},
+    }
+    headers = {
+        "DD-API-KEY": api_key,
+        "DD-APPLICATION-KEY": app_key,
+        "Content-Type": "application/json",
+    }
+    events: list[dict[str, Any]] = []
+    retries = 0
+    with httpx.Client(base_url=f"https://api.{site}", headers=headers, timeout=30) as client:
+        while True:
+            resp = client.post("/api/v2/logs/events/search", json=body)
+            if resp.status_code == 429 and retries < 3:
+                wait = int(
+                    resp.headers.get("Retry-After") or resp.headers.get("X-RateLimit-Reset") or 5
+                )
+                print(f"rate limited; retrying in {wait}s", file=sys.stderr)
+                time.sleep(wait)
+                retries += 1
+                continue
+            if resp.status_code != 200:
+                print(f"Datadog API {resp.status_code}: {resp.text[:500]}", file=sys.stderr)
+                sys.exit(1)
+            payload = resp.json()
+            events.extend(payload.get("data", []))
+            cursor = payload.get("meta", {}).get("page", {}).get("after")
+            if not cursor or len(events) >= limit:
+                break
+            body["page"]["cursor"] = cursor
+    return events[:limit]
+
+
+def full_command(group: str | None, argv: Any) -> str | None:
+    """`command` is only the Click group (e.g. `configuration`); recover the
+    subcommand path from argv: the bare-word tokens that follow the group."""
+    if not group or not isinstance(argv, list):
+        return group
+    try:
+        i = argv.index(group)
+    except ValueError:
+        return group
+    words = [group]
+    for tok in argv[i + 1 : i + 3]:
+        if isinstance(tok, str) and re.fullmatch(r"[a-z][a-z-]*", tok):
+            words.append(tok)
+        else:
+            break
+    return " ".join(words)
+
+
+def flatten(event: dict[str, Any]) -> dict[str, Any]:
+    """Reduce a Datadog log event to the attributes worth reading."""
+    attrs = event.get("attributes", {})
+    custom = attrs.get("attributes", {})  # user attributes live one level down
+    tags = dict(t.split(":", 1) for t in attrs.get("tags", []) if ":" in t)
+    usr = custom.get("usr", {}) or {}
+    err = custom.get("error", {}) or {}
+    return {
+        "id": event.get("id"),
+        "ts": attrs.get("timestamp"),
+        "message": attrs.get("message"),
+        "command": full_command(custom.get("command"), custom.get("argv")),
+        "argv": custom.get("argv"),
+        "error_code": custom.get("error_code") or tags.get("error_code"),
+        "error_class": custom.get("error_class") or err.get("kind"),
+        "error_message": custom.get("error_message") or err.get("message"),
+        "error_stack": custom.get("error_stack") or err.get("stack"),
+        "exit_code": custom.get("exit_code"),
+        "duration_ms": custom.get("duration_ms"),
+        "cli_version": custom.get("version") or tags.get("version"),
+        "org": custom.get("datex_org_name") or tags.get("org"),
+        "python_version": custom.get("python_version"),
+        "os": custom.get("os", {}).get("name")
+        if isinstance(custom.get("os"), dict)
+        else custom.get("os"),
+        "os_release": custom.get("os_release"),
+        "api_target": custom.get("api_target") or tags.get("api_target"),
+        "env": tags.get("env"),
+        "usr_id": usr.get("id"),
+        "usr_email": usr.get("email"),
+        "usr_name": usr.get("name"),
+        "session_id": (custom.get("session") or {}).get("id"),
+        "install_id": custom.get("install_id"),
+        "ctx_branch_id": custom.get("ctx_branch_id"),
+        "ctx_org": custom.get("ctx_org"),
+        "ctx_env": custom.get("ctx_env"),
+    }
+
+
+def print_summary(rows: list[dict[str, Any]]) -> None:
+    if not rows:
+        print("No matching error events.")
+        return
+    groups: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    for r in rows:
+        groups[(r["command"] or "?", r["error_code"] or "-", r["error_class"] or "?")].append(r)
+    print(f"{len(rows)} error events, {len(groups)} distinct (command, code, class)\n")
+    print(f"{'count':>5}  {'command':<28} {'code':<14} {'class':<24} sample message")
+    for key, grp in sorted(groups.items(), key=lambda kv: -len(kv[1])):
+        cmd, code, cls = key
+        msg = (grp[0]["error_message"] or "")[:80].replace("\n", " ")
+        print(f"{len(grp):>5}  {cmd:<28} {code:<14} {cls:<24} {msg}")
+        users = Counter(r["usr_email"] or r["usr_name"] or "?" for r in grp)
+        versions = Counter(r["cli_version"] or "?" for r in grp)
+        print(
+            f"       last={grp[0]['ts']}  users={dict(users.most_common(3))}"
+            f"  versions={dict(versions.most_common(3))}"
+        )
+
+
+def print_list(rows: list[dict[str, Any]]) -> None:
+    for r in rows:
+        msg = (r["error_message"] or "")[:100].replace("\n", " ")
+        print(
+            f"{r['ts']}  {r['cli_version'] or '?':<8} {r['usr_email'] or r['usr_name'] or '?':<32}"
+            f" {r['command'] or '?':<28} {r['error_code'] or '-':<14} {msg}"
+        )
+
+
+def print_detail(rows: list[dict[str, Any]]) -> None:
+    for r in rows:
+        print("=" * 100)
+        for k in SUMMARY_FIELDS + ("argv", "ctx_branch_id", "ctx_org", "session_id", "id"):
+            if r.get(k) is not None:
+                print(f"{k:<14} {r[k]}")
+        if r.get("error_stack"):
+            print("--- stack ---")
+            print(r["error_stack"])
+    print("=" * 100)
+
+
+def main(argv: list[str] | None = None) -> None:
+    p = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    p.add_argument(
+        "--since",
+        type=parse_since,
+        default="24h",
+        help="lookback window, e.g. 30m, 6h, 7d (default 24h)",
+    )
+    p.add_argument("--service", default="dxs-cli", help="Datadog service tag (default dxs-cli)")
+    p.add_argument("--env", help="ddtag env: staging|prod|local (which Quartermaster received it)")
+    p.add_argument("--api-target", help="dev|qa|prod|default (which Datex environment the CLI hit)")
+    p.add_argument("--code", help="filter by DXS-* error code")
+    p.add_argument(
+        "--command", help="filter by Click group, e.g. configuration (subcommand is only in argv)"
+    )
+    p.add_argument("--version", help="filter by cli_version")
+    p.add_argument("-q", "--query", help="extra raw Datadog log query ANDed onto the filter")
+    p.add_argument("-n", "--limit", type=int, default=500, help="max events to fetch (default 500)")
+    mode = p.add_mutually_exclusive_group()
+    mode.add_argument("--list", action="store_true", help="one line per event")
+    mode.add_argument("--detail", action="store_true", help="every field + stack per event")
+    p.add_argument("-f", "--format", choices=["text", "json"], default="text")
+    p.add_argument("--show-query", action="store_true", help="print the Datadog query and exit")
+    args = p.parse_args(argv)
+
+    from dotenv import load_dotenv
+
+    load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+    api_key, app_key = os.environ.get("DATADOG_API_KEY"), os.environ.get("DATADOG_APP_KEY")
+    site = os.environ.get("DATADOG_SITE", "datadoghq.com")
+    if not api_key or not app_key:
+        print("DATADOG_API_KEY and DATADOG_APP_KEY must be set (expected in .env)", file=sys.stderr)
+        sys.exit(1)
+
+    query = build_query(args)
+    if args.show_query:
+        print(query)
+        return
+    print(f"query: {query}   window: last {args.since}", file=sys.stderr)
+
+    rows = [flatten(e) for e in fetch_events(site, api_key, app_key, query, args.since, args.limit)]
+    if args.format == "json":
+        json.dump(rows, sys.stdout, indent=2, default=str)
+        print()
+    elif args.detail:
+        print_detail(rows)
+    elif args.list:
+        print_list(rows)
+    else:
+        print_summary(rows)
+
+
+if __name__ == "__main__":
+    main()