datex-studio-cli 0.4.1__tar.gz → 0.4.3__tar.gz

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.3}/PKG-INFO

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

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

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.3}/scripts/analyze_corpus.py

@@ -226,39 +226,39 @@ def main() -> None:
     for cat, cnt in category_counts.most_common():
         print(f"  {cat:30s} {cnt:4d}")
 
-    print(f"\n## Page Size Distribution")
+    print("\n## Page Size Distribution")
     for size, cnt in page_sizes.most_common():
         pct = cnt / total * 100
         print(f"  {size:30s} {cnt:4d}  ({pct:.0f}%)")
 
-    print(f"\n## Margin Distribution")
+    print("\n## Margin Distribution")
     for margin, cnt in margin_counter.most_common(15):
         pct = cnt / total * 100
         print(f"  {margin:55s} {cnt:4d}  ({pct:.0f}%)")
 
-    print(f"\n## Item Type Frequency")
+    print("\n## Item Type Frequency")
     for typ, cnt in item_type_counter.most_common():
         print(f"  {typ:25s} {cnt:5d}")
 
-    print(f"\n## Barcode Symbology Frequency")
+    print("\n## Barcode Symbology Frequency")
     for sym, cnt in barcode_symbology_counter.most_common():
         print(f"  {sym:25s} {cnt:4d}")
 
-    print(f"\n## Font Usage Frequency (top 20)")
+    print("\n## Font Usage Frequency (top 20)")
     for fnt, cnt in font_counter.most_common(20):
         print(f"  {fnt:30s} {cnt:5d}")
 
-    print(f"\n## Expression Pattern Frequency")
+    print("\n## Expression Pattern Frequency")
     for pat, cnt in expression_pattern_counter.most_common():
         print(f"  {pat:30s} {cnt:5d}")
 
-    print(f"\n## Dataset Count per Report")
+    print("\n## Dataset Count per Report")
     if dataset_counts:
         print(f"  Mean:   {mean(dataset_counts):.1f}")
         print(f"  Median: {median(dataset_counts):.1f}")
         print(f"  Range:  {min(dataset_counts)} - {max(dataset_counts)}")
 
-    print(f"\n## Element Count per Report by Category (body-level items)")
+    print("\n## Element Count per Report by Category (body-level items)")
     for cat in sorted(element_counts_by_category):
         counts = element_counts_by_category[cat]
         if counts:
@@ -269,7 +269,7 @@ def main() -> None:
                 f"n={len(counts)}"
             )
 
-    print(f"\n## Common Field Names by Category (top 10)")
+    print("\n## Common Field Names by Category (top 10)")
     for cat in sorted(field_names_by_category):
         top = field_names_by_category[cat].most_common(10)
         if top:
@@ -277,9 +277,9 @@ def main() -> None:
             for name, cnt in top:
                 print(f"    {name:30s} {cnt:4d}")
 
-    print(f"\n## PageHeader / PageFooter Usage")
-    print(f"  PageHeader: {page_header_count}/{total} ({page_header_count/total*100:.0f}%)")
-    print(f"  PageFooter: {page_footer_count}/{total} ({page_footer_count/total*100:.0f}%)")
+    print("\n## PageHeader / PageFooter Usage")
+    print(f"  PageHeader: {page_header_count}/{total} ({page_header_count / total * 100:.0f}%)")
+    print(f"  PageFooter: {page_footer_count}/{total} ({page_footer_count / total * 100:.0f}%)")
 
 
 if __name__ == "__main__":

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.3}/scripts/generate_rdlx_schema.py

@@ -241,9 +241,22 @@ def compare_schema(item_types: dict, items: list[dict]) -> dict:
         all_schema_props = schema_props | schema_style_props
         corpus_props = set(item_types[type_name]["properties"].keys())
         # Exclude common layout props that aren't type-specific
-        common_layout = {"Type", "Name", "Left", "Top", "Width", "Height", "ZIndex",
-                         "Visibility", "Style", "LayerName", "OverflowName", "Bookmark",
-                         "Label", "CustomProperties"}
+        common_layout = {
+            "Type",
+            "Name",
+            "Left",
+            "Top",
+            "Width",
+            "Height",
+            "ZIndex",
+            "Visibility",
+            "Style",
+            "LayerName",
+            "OverflowName",
+            "Bookmark",
+            "Label",
+            "CustomProperties",
+        }
         missing = sorted((corpus_props - all_schema_props) - common_layout)
         if missing:
             props_not_in_schema[type_name] = missing
@@ -296,13 +309,13 @@ def print_summary(schema: dict) -> None:
     # Common properties
     common = schema.get("common_properties", {})
     if common:
-        print(f"\n## Common Properties (shared across >=80% of item types)")
+        print("\n## Common Properties (shared across >=80% of item types)")
         for prop, info in sorted(common.items()):
             print(f"  {prop:25s}  {info['present_in']}")
 
     # Top properties per type (top 5 by count, excluding common)
     common_names = set(common.keys()) if common else set()
-    print(f"\n## Type-Specific Properties (top 10, excluding common)")
+    print("\n## Type-Specific Properties (top 10, excluding common)")
     for type_name, type_info in sorted(item_types.items(), key=lambda x: -x[1]["count"]):
         props = type_info["properties"]
         specific = [(k, v) for k, v in props.items() if k not in common_names]
@@ -322,41 +335,41 @@ def print_summary(schema: dict) -> None:
     # Comparison
     comp = schema.get("comparison", {})
     if comp and "error" not in comp:
-        print(f"\n## Schema Comparison (corpus vs schema.py)")
+        print("\n## Schema Comparison (corpus vs schema.py)")
 
         types_missing = comp.get("item_types_in_corpus_not_in_schema", [])
         if types_missing:
-            print(f"  Item types in corpus but NOT in schema.py:")
+            print("  Item types in corpus but NOT in schema.py:")
             for t in types_missing:
                 count = item_types.get(t, {}).get("count", "?")
                 print(f"    - {t} ({count} instances)")
 
         types_extra = comp.get("item_types_in_schema_not_in_corpus", [])
         if types_extra:
-            print(f"  Item types in schema.py but NOT in corpus:")
+            print("  Item types in schema.py but NOT in corpus:")
             for t in types_extra:
                 print(f"    - {t}")
 
         props_missing = comp.get("properties_in_corpus_not_in_schema", {})
         if props_missing:
-            print(f"  Properties in corpus but NOT in schema.py:")
+            print("  Properties in corpus but NOT in schema.py:")
             for type_name, props in sorted(props_missing.items()):
                 print(f"    {type_name}: {', '.join(props)}")
 
         sym_missing = comp.get("symbologies_in_corpus_not_in_schema", [])
         if sym_missing:
-            print(f"  Barcode symbologies in corpus but NOT in schema.py:")
+            print("  Barcode symbologies in corpus but NOT in schema.py:")
             for s in sym_missing:
                 print(f"    - {s}")
 
         sym_extra = comp.get("symbologies_in_schema_not_in_corpus", [])
         if sym_extra:
-            print(f"  Barcode symbologies in schema.py but NOT in corpus:")
+            print("  Barcode symbologies in schema.py but NOT in corpus:")
             for s in sym_extra:
                 print(f"    - {s}")
 
     if not comp or all(not v for v in comp.values() if isinstance(v, (list, dict))):
-        print(f"\n  Schema comparison: no gaps found!")
+        print("\n  Schema comparison: no gaps found!")
 
 
 # ── Main ─────────────────────────────────────────────────────────────────
@@ -364,12 +377,23 @@ def print_summary(schema: dict) -> None:
 
 def main() -> None:
     parser = argparse.ArgumentParser(description="Generate RDLX-JSON schema from report corpus")
-    parser.add_argument("directory", nargs="?", default="example-reports",
-                        help="Directory containing .rdlx-json files (default: example-reports/)")
-    parser.add_argument("-o", "--output", default="corpus-schema.json",
-                        help="Output JSON file path (default: corpus-schema.json)")
-    parser.add_argument("--summary-only", action="store_true",
-                        help="Print human-readable summary only, skip JSON output")
+    parser.add_argument(
+        "directory",
+        nargs="?",
+        default="example-reports",
+        help="Directory containing .rdlx-json files (default: example-reports/)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="corpus-schema.json",
+        help="Output JSON file path (default: corpus-schema.json)",
+    )
+    parser.add_argument(
+        "--summary-only",
+        action="store_true",
+        help="Print human-readable summary only, skip JSON output",
+    )
     args = parser.parse_args()
 
     root = Path(args.directory)

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.3}/src/dxs/__init__.py

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

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.3}/src/dxs/cli.py

@@ -38,6 +38,37 @@ def set_last_output_format(fmt: OutputFormat) -> None:
     _last_output_format = fmt
 
 
+def _format_set_in_env_or_config() -> bool:
+    """Whether ``default_output_format`` was set explicitly outside CLI flags.
+
+    Used to decide if TTY-auto-script mode should override the default format.
+    Returns True when either ``DXS_DEFAULT_OUTPUT_FORMAT`` is in the environment
+    or the config file contains a ``default_output_format`` entry.
+    """
+    import os
+
+    from dxs.utils.config import load_config_file
+
+    if os.environ.get("DXS_DEFAULT_OUTPUT_FORMAT"):
+        return True
+    try:
+        return bool(load_config_file().get("default_output_format"))
+    except Exception:  # noqa: BLE001 - config read should never block startup
+        return False
+
+
+def _stdout_is_pipe() -> bool:
+    """Whether stdout looks like a non-interactive consumer (pipe/redirect).
+
+    Pulled into a helper so tests can patch it independently of Click's
+    CliRunner, which swaps ``sys.stdout`` with a non-TTY StringIO.
+    """
+    try:
+        return not sys.stdout.isatty()
+    except (AttributeError, ValueError):
+        return False
+
+
 # Global options shared across all commands
 CONTEXT_SETTINGS = {
     "help_option_names": ["-h", "--help"],
@@ -140,6 +171,13 @@ class DxsGroup(click.Group):
     default=False,
     help="Show full output including null values and verbose metadata",
 )
+@click.option(
+    "--flat-fv/--no-flat-fv",
+    "flat_fv",
+    default=None,
+    help="Flatten Dynamics @OData FormattedValue siblings into clean keys. "
+    "Defaults to on with --concise (the default mode); pass --no-flat-fv to opt out.",
+)
 @click.option(
     "-s",
     "--save",
@@ -181,6 +219,7 @@ def cli(
     verbose: bool,
     quiet: bool,
     full: bool,
+    flat_fv: bool | None,
     save_path: str | None,
     force_overwrite: bool,
     diagnose_auth: bool,
@@ -229,19 +268,40 @@ def cli(
     # Load settings
     settings = get_settings()
 
-    # Set output format (CLI flag > env var > config > default)
+    # When stdout is not a TTY (piped/redirected), assume a script consumer:
+    # default to JSON output and suppress progress banners unless the user
+    # has explicitly chosen otherwise via CLI flag, env var, or config file.
+    piped = _stdout_is_pipe()
+    click_ctx = click.get_current_context()
+    quiet_src = click_ctx.get_parameter_source("quiet")
+    fmt_explicit_in_env_or_config = _format_set_in_env_or_config()
+
+    # Set output format (CLI flag > env var > config > TTY auto > default)
     if output_format:
         dxs_ctx.output_format = OutputFormat(output_format.lower())
         dxs_ctx.explicit_output_format = True
+    elif fmt_explicit_in_env_or_config and settings.default_output_format:
+        dxs_ctx.output_format = OutputFormat(settings.default_output_format.lower())
+    elif piped:
+        dxs_ctx.output_format = OutputFormat.JSON
     elif settings.default_output_format:
         dxs_ctx.output_format = OutputFormat(settings.default_output_format.lower())
     set_last_output_format(dxs_ctx.output_format)
 
     # Set verbosity (--verbose enables debug output, --quiet suppresses progress)
     dxs_ctx.verbose = verbose
-    dxs_ctx.quiet = quiet
+    if quiet_src == click.core.ParameterSource.COMMANDLINE:
+        dxs_ctx.quiet = quiet
+    else:
+        dxs_ctx.quiet = quiet or piped
     # Concise output is default; --full disables it
     dxs_ctx.concise = not full
+    # Flatten Dynamics FormattedValue siblings: follow --concise unless
+    # --flat-fv / --no-flat-fv was passed explicitly.
+    if flat_fv is None:
+        dxs_ctx.flat_fv = dxs_ctx.concise
+    else:
+        dxs_ctx.flat_fv = flat_fv
 
     # Set save options
     dxs_ctx.save_path = save_path
@@ -260,6 +320,17 @@ def cli(
     # Stash for the result_callback to honor --no-update-check
     dxs_ctx.no_update_check = no_update_check
 
+    # Telemetry: record invocation start (must come before any subcommand runs).
+    # Wrapped so a telemetry bug can never block the CLI.
+    try:
+        from dxs.core.telemetry import maybe_show_first_run_notice, record_start
+
+        invoked = ctx.invoked_subcommand or "<root>"
+        record_start(argv=sys.argv[1:], command=invoked)
+        maybe_show_first_run_notice()
+    except Exception:  # noqa: BLE001
+        pass
+
 
 def _mask_token(token: str | None, visible_chars: int = 8) -> str:
     """Mask a token for display, showing only first/last few characters.
@@ -316,18 +387,30 @@ def handle_errors(f: F) -> F:
         try:
             return ctx.invoke(f, *args, **kwargs)
         except DxsError as e:
+            _record_error_silently(e)
             dxs_ctx.output_error(e)
             sys.exit(1)
         except click.ClickException:
             # Let Click handle its own exceptions
             raise
         except Exception as e:
+            _record_error_silently(e)
             dxs_ctx.output_error(e)
             sys.exit(1)
 
     return cast(F, wrapper)
 
 
+def _record_error_silently(exc: BaseException) -> None:
+    """Emit a telemetry error event; never raises."""
+    try:
+        from dxs.core.telemetry import record_error
+
+        record_error(exc)
+    except Exception:  # noqa: BLE001
+        pass
+
+
 # Import and register command groups
 # These imports are here to avoid circular imports
 def register_commands() -> None:
@@ -336,6 +419,7 @@ def register_commands() -> None:
         api,
         auth,
         config,
+        configuration,
         crm,
         datasource,
         devops,
@@ -355,6 +439,8 @@ def register_commands() -> None:
     cli.add_command(api.api)
     cli.add_command(auth.auth)
     cli.add_command(config.config)
+    cli.add_command(config.config, name="settings")
+    cli.add_command(configuration.configuration)
     cli.add_command(crm.crm)
     cli.add_command(datasource.datasource)
     cli.add_command(devops.devops)
@@ -376,14 +462,30 @@ def register_commands() -> None:
 
     cli.add_command(schema.schema)
 
+    # Telemetry subcommands (status / enable / disable / test)
+    from dxs.commands import telemetry as telemetry_cmd
+
+    cli.add_command(telemetry_cmd.telemetry)
+
 
 @cli.result_callback()
 @click.pass_context
 def _after_command(ctx: click.Context, result: Any, **kwargs: Any) -> Any:
-    """Run post-command hooks (currently: PyPI update notice)."""
+    """Run post-command hooks (telemetry success event + PyPI update notice)."""
     from dxs.utils.update_check import maybe_show_update_notice
 
     dxs_ctx: DxsContext | None = ctx.find_object(DxsContext)
+
+    # Emit a success event. handle_errors-decorated commands never reach here
+    # on failure, so the only path through this branch is a successful run.
+    try:
+        from dxs.core.telemetry import record_end
+
+        ctx_extras = _ctx_extras(dxs_ctx)
+        record_end(exit_code=0, ctx_extras=ctx_extras)
+    except Exception:  # noqa: BLE001
+        pass
+
     skip = bool(dxs_ctx and dxs_ctx.no_update_check)
     try:
         maybe_show_update_notice(skip=skip)
@@ -392,6 +494,18 @@ def _after_command(ctx: click.Context, result: Any, **kwargs: Any) -> Any:
     return result
 
 
+def _ctx_extras(dxs_ctx: "DxsContext | None") -> dict[str, Any]:
+    """Pluck branch/repo/org/env from DxsContext for telemetry events."""
+    if dxs_ctx is None:
+        return {}
+    return {
+        "branch_id": dxs_ctx.branch,
+        "repo_id": dxs_ctx.repo,
+        "org": dxs_ctx.org,
+        "env": dxs_ctx.env,
+    }
+
+
 @cli.command("update")
 @click.option(
     "--check",
@@ -438,13 +552,30 @@ register_commands()
 def main() -> None:
     """Main entry point for the CLI."""
     try:
-        cli()
-    except DxsError as e:
-        # Use the module-level format captured during CLI init
-        # (Click context is torn down before exceptions reach here)
-        formatted = format_error(e, _last_output_format)
-        click.echo(formatted, err=True)
-        sys.exit(1)
+        try:
+            cli()
+        except DxsError as e:
+            _record_error_silently(e)
+            # Use the module-level format captured during CLI init
+            # (Click context is torn down before exceptions reach here)
+            formatted = format_error(e, _last_output_format)
+            click.echo(formatted, err=True)
+            sys.exit(1)
+        except SystemExit:
+            # SystemExit from sys.exit() inside handle_errors — telemetry already
+            # recorded an error there; just propagate.
+            raise
+        except BaseException as e:
+            # Anything else escaping cli() shouldn't take telemetry with it.
+            _record_error_silently(e)
+            raise
+    finally:
+        try:
+            from dxs.core.telemetry import flush
+
+            flush(timeout=0.5)
+        except Exception:  # noqa: BLE001
+            pass
 
 
 if __name__ == "__main__":