pbi-enterprise-cli 0.1.0.dev0__py3-none-any.whl

pbi_cli/commands/govern.py

@@ -0,0 +1,124 @@
+"""pbi govern — governance rules, lint, auto-fix (Epic D)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from pbi_cli._audit import write_audit_entry
+from pbi_cli.commands._shared import dry_run_echo, get_backend, output_json_or_table
+
+console = Console()
+
+
+@click.group()
+def govern() -> None:
+    """Enforce naming conventions, required metadata, and model quality rules."""
+
+
+@govern.command("init")
+@click.pass_context
+def govern_init(ctx: click.Context) -> None:
+    """Create ~/.pbi-cli/governance.json with default rules."""
+    config_dir = Path.home() / ".pbi-cli"
+    config_dir.mkdir(exist_ok=True)
+    config_file = config_dir / "governance.json"
+    if config_file.exists():
+        console.print(f"[yellow]Already exists:[/yellow] {config_file}")
+        return
+    defaults = {
+        "naming": {
+            "tables": "PascalCase",
+            "measures": "Title Case in [Brackets]",
+            "hiddenPrefix": "_",
+            "factPrefix": "FACT_",
+            "dimPrefix": "DIM_",
+        },
+        "required": {
+            "measureDescription": True,
+            "tableDataCategory": False,
+        },
+        "complexity": {
+            "maxMeasureLength": 500,
+            "maxIteratorDepth": 3,
+        },
+    }
+    config_file.write_text(json.dumps(defaults, indent=2), encoding="utf-8")
+    console.print(f"[green]Created:[/green] {config_file}")
+
+
+@govern.command("check")
+@click.pass_context
+def govern_check(ctx: click.Context) -> None:
+    """Run all governance rules; output violations with severity (error/warning/info)."""
+    from pbi_cli.governance.engine import GovernanceEngine
+
+    backend = get_backend(ctx)
+    engine = GovernanceEngine(backend)
+    violations = engine.run_all()
+    is_json = ctx.obj and ctx.obj.get("output_json")
+    if violations:
+        errors = [v for v in violations if v["severity"] == "error"]
+        warnings_list = [v for v in violations if v["severity"] == "warning"]
+        if not is_json:
+            console.print(
+                f"[red]{len(errors)} errors[/red], [yellow]{len(warnings_list)} warnings[/yellow]"
+            )
+        output_json_or_table(violations, ctx, title="Governance Violations")
+        if errors:
+            raise SystemExit(1)
+    else:
+        if not is_json:
+            console.print("[green]All governance checks pass.[/green]")
+        else:
+            import click
+
+            click.echo("[]")
+
+
+@govern.command("fix")
+@click.option("--auto", is_flag=True, help="Auto-fix safe violations.")
+@click.pass_context
+def govern_fix(ctx: click.Context, auto: bool) -> None:
+    """Auto-fix safe violations: PascalCase, FORMAT strings, folder sort."""
+    from pbi_cli.governance.engine import GovernanceEngine
+
+    backend = get_backend(ctx)
+    engine = GovernanceEngine(backend)
+    violations = engine.run_all()
+    fixable = [v for v in violations if v.get("autoFixable")]
+    console.print(f"[cyan]{len(fixable)} auto-fixable violations[/cyan]")
+    if not auto:
+        console.print("Use --auto to apply fixes.")
+        return
+    if dry_run_echo(ctx, f"apply {len(fixable)} auto-fixes"):
+        return
+    fixed = engine.auto_fix(fixable)
+    write_audit_entry("govern fix", extra={"violations_fixed": fixed})
+    console.print(f"[green]Fixed {fixed} violations.[/green]")
+
+
+@govern.command("rules")
+@click.pass_context
+def govern_rules(ctx: click.Context) -> None:
+    """List all registered governance rules (built-in and plugins).
+
+    \b
+    Plugin rules are loaded from: ~/.pbi-cli/rules/*.py
+    Each plugin file must expose: RULE_ID (str) and check(backend) -> list[dict]
+    """
+    from pbi_cli.commands._shared import output_json_or_table
+    from pbi_cli.governance.engine import GovernanceEngine
+
+    rules = GovernanceEngine.list_rules()
+    output_json_or_table(rules, ctx, title="Governance Rules")
+    plugin_count = sum(1 for r in rules if r["source"] == "plugin")
+    if plugin_count:
+        console.print(f"\n[cyan]{plugin_count} plugin rule(s) loaded[/cyan] from ~/.pbi-cli/rules/")
+    else:
+        console.print(
+            "\n[yellow]No plugin rules loaded.[/yellow] Place *.py rule files in ~/.pbi-cli/rules/"
+        )

pbi_cli/commands/layout.py

@@ -0,0 +1,104 @@
+"""pbi layout — auto-layout engine commands (Epic C)."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+from pbi_cli.commands._shared import dry_run_echo, output_json_or_table
+
+console = Console()
+
+
+@click.group()
+def layout() -> None:
+    """Auto-position visuals using the shelf-packing layout engine."""
+
+
+@layout.command("auto")
+@click.option("--pbip", required=True, help="Path to the .pbip project folder or file.")
+@click.option("--page", required=True, help="Page name to layout.")
+@click.option("--canvas-width", default=1280, show_default=True)
+@click.option("--canvas-height", default=720, show_default=True)
+@click.pass_context
+def layout_auto(
+    ctx: click.Context, pbip: str, page: str, canvas_width: int, canvas_height: int
+) -> None:
+    """Load all visuals from a PBIR page, classify them, and repack onto the canvas."""
+    from pbi_cli.backends.pbir_backend import PbirBackend
+    from pbi_cli.intelligence.layout_engine import LayoutEngine
+
+    console.print(f"[cyan]Auto-layout:[/cyan] page '{page}' ({canvas_width}x{canvas_height})")
+    pbir = PbirBackend(pbip)
+    visuals = pbir.visual_list(page)
+
+    if not visuals:
+        console.print(f"[yellow]No visuals found on page '{page}'.[/yellow]")
+        return
+
+    console.print(f"[dim]Found {len(visuals)} visuals — classifying and packing...[/dim]")
+    engine = LayoutEngine(canvas_width=canvas_width, canvas_height=canvas_height)
+    positions = engine.pack(visuals)
+
+    if dry_run_echo(ctx, f"apply {len(positions)} visual positions to page '{page}'"):
+        output_json_or_table(positions, ctx, title="Visual Layout (dry run)")
+        return
+
+    # Write positions back to PBIR files
+    from pbi_cli._audit import write_audit_entry
+
+    for pos in positions:
+        vd = pbir._ga_visuals_dir(page)  # type: ignore[attr-defined]
+        if vd is None:
+            continue
+        for vdir in vd.iterdir():
+            if not vdir.is_dir():
+                continue
+            vj = vdir / "visual.json"
+            if not vj.exists():
+                continue
+            import json
+
+            data = json.loads(vj.read_text(encoding="utf-8"))
+            if data.get("name") == pos["name"]:
+                data.setdefault("position", {}).update(
+                    {
+                        "x": pos["x"],
+                        "y": pos["y"],
+                        "width": pos["width"],
+                        "height": pos["height"],
+                    }
+                )
+                vj.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    write_audit_entry("layout auto", extra={"page": page, "visuals_repositioned": len(positions)})
+    console.print(f"[green]Repositioned[/green] {len(positions)} visuals on page '{page}'")
+    output_json_or_table(positions, ctx, title="Visual Layout")
+
+
+@layout.command("template")
+@click.option(
+    "--name",
+    required=True,
+    type=click.Choice(
+        ["executive-dashboard", "operational-monitor", "financial-report", "drill-through-detail"]
+    ),
+)
+@click.option("--page", required=True, help="Page name.")
+@click.pass_context
+def layout_template(ctx: click.Context, name: str, page: str) -> None:
+    """Apply a named layout template to a page."""
+    templates = {
+        "executive-dashboard": [
+            "KPI Strip (top 15%)",
+            "Main Chart (center 60%)",
+            "Table (bottom 25%)",
+            "Slicer Rail (right 20%)",
+        ],
+        "operational-monitor": ["KPI Strip", "Real-time Chart", "Alert Table"],
+        "financial-report": ["Header", "YTD KPIs", "Trend Chart", "Variance Table"],
+        "drill-through-detail": ["Filter Panel", "Detail Table", "Supporting Chart"],
+    }
+    console.print(f"[cyan]Template:[/cyan] {name} -> page '{page}'")
+    for zone in templates[name]:
+        console.print(f"  [dim]Zone:[/dim] {zone}")

pbi_cli/commands/measure.py

@@ -0,0 +1,185 @@
+"""pbi measure — DAX measure CRUD commands."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+from pbi_cli._audit import write_audit_entry
+from pbi_cli.commands._shared import (
+    dry_run_echo,
+    get_backend,
+    output_json_or_table,
+    snapshot_before_write,
+)
+
+console = Console()
+
+
+@click.group()
+def measure() -> None:
+    """Manage DAX measures: add, list, update, delete, generate, audit."""
+
+
+@measure.command("list")
+@click.option("--table", default=None, help="Filter to a specific table.")
+@click.pass_context
+def measure_list(ctx: click.Context, table: str | None) -> None:
+    """List all measures in the connected model."""
+    backend = get_backend(ctx)
+    if not backend.is_connected():
+        console.print("[red]Not connected. Use 'pbi connect' first.[/red]")
+        raise click.Abort()
+    data = backend.measure_list(table=table)
+    output_json_or_table(data, ctx, title="Measures")
+
+
+@measure.command("add")
+@click.option("--table", required=True, help="Table to add the measure to.")
+@click.option("--name", required=True, help="Measure name (use [Brackets] convention).")
+@click.option("--expression", required=True, help="DAX expression.")
+@click.option("--format-string", default=None, help="Format string (e.g. #,0.00).")
+@click.option("--description", default=None, help="Measure description.")
+@click.pass_context
+def measure_add(
+    ctx: click.Context,
+    table: str,
+    name: str,
+    expression: str,
+    format_string: str | None,
+    description: str | None,
+) -> None:
+    """Add a new DAX measure."""
+    detail = f"measure '{name}' to '{table}': {expression}"
+    if dry_run_echo(ctx, f"add measure '{name}' to table '{table}'", detail):
+        return
+    backend = get_backend(ctx)
+    snapshot_before_write(ctx)
+    kwargs = {}
+    if format_string:
+        kwargs["formatString"] = format_string
+    if description:
+        kwargs["description"] = description
+    result = backend.measure_add(table=table, name=name, expression=expression, **kwargs)
+    write_audit_entry("measure add", after=result)
+    if not (ctx.obj and ctx.obj.get("output_json")):
+        console.print(f"[green]Added[/green] measure '{name}' to '{table}'")
+    output_json_or_table(result, ctx)
+
+
+@measure.command("update")
+@click.option("--table", required=True, help="Table containing the measure.")
+@click.option("--name", required=True, help="Measure name to update.")
+@click.option("--expression", default=None, help="New DAX expression.")
+@click.option("--format-string", default=None, help="New format string.")
+@click.option("--description", default=None, help="New description.")
+@click.pass_context
+def measure_update(
+    ctx: click.Context,
+    table: str,
+    name: str,
+    expression: str | None,
+    format_string: str | None,
+    description: str | None,
+) -> None:
+    """Update an existing DAX measure (expression, format string, or description)."""
+    kwargs: dict = {}
+    if expression:
+        kwargs["expression"] = expression
+    if format_string:
+        kwargs["formatString"] = format_string
+    if description:
+        kwargs["description"] = description
+    if not kwargs:
+        console.print("[yellow]Nothing to update — provide at least one option.[/yellow]")
+        return
+    detail = f"update measure '{name}' in '{table}': {kwargs}"
+    if dry_run_echo(ctx, f"update measure '{name}' in table '{table}'", detail):
+        return
+    backend = get_backend(ctx)
+    snapshot_before_write(ctx)
+    before = next((m for m in backend.measure_list(table=table) if m["name"] == name), None)
+    result = backend.measure_update(table=table, name=name, **kwargs)
+    write_audit_entry("measure update", before=before, after=result)
+    if not (ctx.obj and ctx.obj.get("output_json")):
+        console.print(f"[green]Updated[/green] measure '{name}' in '{table}'")
+    output_json_or_table(result, ctx)
+
+
+@measure.command("delete")
+@click.option("--table", required=True, help="Table containing the measure.")
+@click.option("--name", required=True, help="Measure name to delete.")
+@click.pass_context
+def measure_delete(ctx: click.Context, table: str, name: str) -> None:
+    """Delete a measure."""
+    if dry_run_echo(ctx, f"delete measure '{name}' from '{table}'"):
+        return
+    backend = get_backend(ctx)
+    snapshot_before_write(ctx)
+    before = next((m for m in backend.measure_list(table=table) if m["name"] == name), None)
+    backend.measure_delete(table=table, name=name)
+    write_audit_entry("measure delete", before=before)
+    console.print(f"[red]Deleted[/red] measure '{name}' from '{table}'")
+
+
+@measure.command("generate")
+@click.argument("description")
+@click.option("--table", required=True, help="Target table.")
+@click.option("--name", required=True, help="Measure name.")
+@click.pass_context
+def measure_generate(ctx: click.Context, description: str, table: str, name: str) -> None:
+    """Generate a DAX measure from a natural language description using Claude."""
+    from pbi_cli.intelligence.measure_generator import MeasureGenerator
+
+    console.print(f"[cyan]Generating DAX for:[/cyan] {description}")
+    backend = get_backend(ctx)
+    schema = backend.column_list() if backend.is_connected() else []
+    gen = MeasureGenerator()
+    result = gen.generate(description=description, schema=schema)
+    expression = result.get("expression", "")
+    console.print(f"[bold]Generated DAX:[/bold]\n{expression}")
+
+    if not result.get("valid"):
+        console.print(f"[yellow]Generation failed:[/yellow] {result.get('error')}")
+        console.print("Review the expression above and add manually.")
+        return
+
+    # Validate the generated DAX via the backend before writing
+    console.print("[cyan]Validating DAX...[/cyan]")
+    validation = backend.dax_validate(expression)
+    if not validation.get("valid", True):
+        console.print("[yellow]DAX validation failed — showing expression for review:[/yellow]")
+        console.print(f"  {validation.get('error', 'Syntax error')}")
+        console.print("Use 'pbi measure add' to write it manually after correction.")
+        return
+
+    if dry_run_echo(ctx, f"add measure '{name}' to '{table}'", expression):
+        return
+    backend.measure_add(table=table, name=name, expression=expression)
+    write_audit_entry(
+        "measure generate", after={"table": table, "name": name, "expression": expression}
+    )
+    console.print(f"[green]Written[/green] measure '{name}' to '{table}'")
+
+
+@measure.command("audit")
+@click.pass_context
+def measure_audit(ctx: click.Context) -> None:
+    """Audit all measures: unused, circular deps, missing FORMAT, hardcoded dates."""
+    backend = get_backend(ctx)
+    measures = backend.measure_list()
+    issues: list[dict] = []
+    for m in measures:
+        expr = m.get("expression", "")
+        if not m.get("formatString"):
+            issues.append(
+                {"measure": m["name"], "issue": "missing FORMAT string", "severity": "warning"}
+            )
+        if "NOW()" in expr.upper() or "TODAY()" in expr.upper():
+            issues.append(
+                {"measure": m["name"], "issue": "hardcoded date function", "severity": "warning"}
+            )
+    if issues:
+        output_json_or_table(issues, ctx, title="Measure Audit Issues")
+    else:
+        console.print("[green]No issues found.[/green]")