pvw-cli 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

purviewcli/cli/unified_catalog.py

@@ -11,11 +11,20 @@ import os
 from rich.console import Console
 from rich.table import Table
 from rich.text import Text
+from rich.syntax import Syntax
 from purviewcli.client._unified_catalog import UnifiedCatalogClient
 
 console = Console()
 
 
+def _format_json_output(data):
+    """Format JSON output with syntax highlighting using Rich"""
+    # Pretty print JSON with syntax highlighting
+    json_str = json.dumps(data, indent=2)
+    syntax = Syntax(json_str, "json", theme="monokai", line_numbers=True)
+    console.print(syntax)
+
+
 @click.group()
 def uc():
     """Manage Unified Catalog in Microsoft Purview (domains, terms, data products, OKRs, CDEs)."""
@@ -88,7 +97,8 @@ def create(name, description, type, owner_id, status):
 
 
 @domain.command(name="list")
-def list_domains():
+@click.option("--json", "output_json", is_flag=True, help="Output results in JSON format")
+def list_domains(output_json):
     """List all governance domains."""
     try:
         client = UnifiedCatalogClient()
@@ -111,6 +121,11 @@ def list_domains():
             console.print("[yellow]No governance domains found.[/yellow]")
             return
 
+        # Output in JSON format if requested
+        if output_json:
+            _format_json_output(domains)
+            return
+
         table = Table(title="Governance Domains")
         table.add_column("ID", style="cyan")
         table.add_column("Name", style="green")
@@ -243,7 +258,8 @@ def create(
 @dataproduct.command(name="list")
 @click.option("--domain-id", required=False, help="Governance domain ID (optional filter)")
 @click.option("--status", required=False, help="Status filter (Draft, Published, Archived)")
-def list_data_products(domain_id, status):
+@click.option("--json", "output_json", is_flag=True, help="Output results in JSON format")
+def list_data_products(domain_id, status, output_json):
     """List all data products (optionally filtered by domain or status)."""
     try:
         client = UnifiedCatalogClient()
@@ -274,24 +290,35 @@ def list_data_products(domain_id, status):
             console.print(f"[yellow]No data products found{filter_msg}.[/yellow]")
             return
 
+        # Output in JSON format if requested
+        if output_json:
+            _format_json_output(products)
+            return
+
         table = Table(title="Data Products")
-        table.add_column("ID", style="cyan")
+        table.add_column("ID", style="cyan", no_wrap=True)
         table.add_column("Name", style="green")
-        table.add_column("Domain ID", style="blue")
+        table.add_column("Domain ID", style="blue", no_wrap=True)
         table.add_column("Status", style="yellow")
-        table.add_column("Description", style="white")
+        table.add_column("Description", style="white", max_width=50)
 
         for product in products:
+            # Get domain ID and handle "N/A" display
+            domain_id = product.get("domain") or product.get("domainId", "")
+            domain_display = domain_id if domain_id else "N/A"
+            
+            # Clean HTML tags from description
+            description = product.get("description", "")
+            import re
+            description = re.sub(r'<[^>]+>', '', description)
+            description = description.strip()
+            
             table.add_row(
                 product.get("id", "N/A"),
                 product.get("name", "N/A"),
-                product.get("domainId", "N/A"),
+                domain_display,
                 product.get("status", "N/A"),
-                (
-                    (product.get("description", "")[:50] + "...")
-                    if len(product.get("description", "")) > 50
-                    else product.get("description", "")
-                ),
+                (description[:50] + "...") if len(description) > 50 else description,
             )
 
         console.print(table)
@@ -322,10 +349,417 @@ def show(product_id):
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
 
+@dataproduct.command()
+@click.option("--product-id", required=True, help="ID of the data product to update")
+@click.option("--name", required=False, help="Name of the data product")
+@click.option("--description", required=False, help="Description of the data product")
+@click.option("--domain-id", required=False, help="Governance domain ID")
+@click.option(
+    "--type",
+    required=False,
+    type=click.Choice(["Operational", "Analytical", "Reference"]),
+    help="Type of data product",
+)
+@click.option(
+    "--owner-id",
+    required=False,
+    help="Owner Entra ID (can be specified multiple times)",
+    multiple=True,
+)
+@click.option("--business-use", required=False, help="Business use description")
+@click.option(
+    "--update-frequency",
+    required=False,
+    type=click.Choice(["Daily", "Weekly", "Monthly", "Quarterly", "Annually"]),
+    help="Update frequency",
+)
+@click.option("--endorsed", is_flag=True, help="Mark as endorsed")
+@click.option(
+    "--status",
+    required=False,
+    type=click.Choice(["Draft", "Published", "Archived"]),
+    help="Status of the data product",
+)
+def update(
+    product_id, name, description, domain_id, type, owner_id, business_use, update_frequency, endorsed, status
+):
+    """Update an existing data product."""
+    try:
+        client = UnifiedCatalogClient()
+
+        # Build args dictionary - only include provided values
+        args = {"--product-id": [product_id]}
+        
+        if name:
+            args["--name"] = [name]
+        if description is not None:  # Allow empty string
+            args["--description"] = [description]
+        if domain_id:
+            args["--domain-id"] = [domain_id]
+        if type:
+            args["--type"] = [type]
+        if status:
+            args["--status"] = [status]
+        if business_use is not None:
+            args["--business-use"] = [business_use]
+        if update_frequency:
+            args["--update-frequency"] = [update_frequency]
+        if endorsed:
+            args["--endorsed"] = ["true"]
+        if owner_id:
+            args["--owner-id"] = list(owner_id)
+
+        result = client.update_data_product(args)
+
+        if not result:
+            console.print("[red]ERROR:[/red] No response received")
+            return
+        if isinstance(result, dict) and "error" in result:
+            console.print(f"[red]ERROR:[/red] {result.get('error', 'Unknown error')}")
+            return
+
+        console.print(f"[green]✅ SUCCESS:[/green] Updated data product '{product_id}'")
+        console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        console.print(f"[red]ERROR:[/red] {str(e)}")
+
+
+@dataproduct.command()
+@click.option("--product-id", required=True, help="ID of the data product to delete")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
+def delete(product_id, yes):
+    """Delete a data product."""
+    try:
+        if not yes:
+            confirm = click.confirm(
+                f"Are you sure you want to delete data product '{product_id}'?",
+                default=False
+            )
+            if not confirm:
+                console.print("[yellow]Deletion cancelled.[/yellow]")
+                return
+
+        client = UnifiedCatalogClient()
+        args = {"--product-id": [product_id]}
+        result = client.delete_data_product(args)
+
+        # DELETE operations may return empty response on success
+        if result is None or (isinstance(result, dict) and not result.get("error")):
+            console.print(f"[green]✅ SUCCESS:[/green] Deleted data product '{product_id}'")
+        elif isinstance(result, dict) and "error" in result:
+            console.print(f"[red]ERROR:[/red] {result.get('error', 'Unknown error')}")
+        else:
+            console.print(f"[green]✅ SUCCESS:[/green] Deleted data product '{product_id}'")
+            if result:
+                console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        console.print(f"[red]ERROR:[/red] {str(e)}")
+
+
+# ========================================
+# GLOSSARIES
+# ========================================
+
+
+@uc.group()
+def glossary():
+    """Manage glossaries (for finding glossary GUIDs)."""
+    pass
+
+
+@glossary.command(name="list")
+@click.option("--json", "output_json", is_flag=True, help="Output results in JSON format")
+def list_glossaries(output_json):
+    """List all glossaries with their GUIDs."""
+    try:
+        from purviewcli.client._glossary import Glossary
+        
+        client = Glossary()
+        result = client.glossaryRead({})
+
+        # Normalize response
+        if isinstance(result, dict):
+            glossaries = result.get("value", []) or []
+        elif isinstance(result, (list, tuple)):
+            glossaries = result
+        else:
+            glossaries = []
+
+        if not glossaries:
+            console.print("[yellow]No glossaries found.[/yellow]")
+            return
+
+        # Output in JSON format if requested
+        if output_json:
+            _format_json_output(glossaries)
+            return
+
+        table = Table(title="Glossaries")
+        table.add_column("GUID", style="cyan", no_wrap=True)
+        table.add_column("Name", style="green")
+        table.add_column("Qualified Name", style="yellow")
+        table.add_column("Description", style="white")
+
+        for g in glossaries:
+            if not isinstance(g, dict):
+                continue
+            table.add_row(
+                g.get("guid", "N/A"),
+                g.get("name", "N/A"),
+                g.get("qualifiedName", "N/A"),
+                (g.get("shortDescription", "")[:60] + "...") if len(g.get("shortDescription", "")) > 60 else g.get("shortDescription", ""),
+            )
+
+        console.print(table)
+        console.print("\n[dim]Tip: Use the GUID with --glossary-guid option when listing/creating terms[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]ERROR:[/red] {str(e)}")
+
+
+@glossary.command(name="create")
+@click.option("--name", required=True, help="Name of the glossary")
+@click.option("--description", required=False, default="", help="Description of the glossary")
+@click.option("--domain-id", required=False, help="Associate with governance domain ID (optional)")
+def create_glossary(name, description, domain_id):
+    """Create a new glossary."""
+    try:
+        from purviewcli.client._glossary import Glossary
+        
+        client = Glossary()
+        
+        # Build qualified name - include domain_id if provided
+        if domain_id:
+            qualified_name = f"{name}@{domain_id}"
+        else:
+            qualified_name = name
+        
+        payload = {
+            "name": name,
+            "qualifiedName": qualified_name,
+            "shortDescription": description,
+            "longDescription": description,
+        }
+        
+        result = client.glossaryCreate({"--payloadFile": payload})
+        
+        if not result:
+            console.print("[red]ERROR:[/red] No response received")
+            return
+        if isinstance(result, dict) and "error" in result:
+            console.print(f"[red]ERROR:[/red] {result.get('error', 'Unknown error')}")
+            return
+        
+        guid = result.get("guid") if isinstance(result, dict) else None
+        console.print(f"[green]✅ SUCCESS:[/green] Created glossary '{name}'")
+        if guid:
+            console.print(f"[cyan]GUID:[/cyan] {guid}")
+            console.print(f"\n[dim]Use this GUID: --glossary-guid {guid}[/dim]")
+        console.print(json.dumps(result, indent=2))
+        
+    except Exception as e:
+        console.print(f"[red]ERROR:[/red] {str(e)}")
+
+
+@glossary.command(name="create-for-domains")
+def create_glossaries_for_domains():
+    """Create glossaries for all governance domains that don't have one."""
+    try:
+        from purviewcli.client._glossary import Glossary
+        
+        uc_client = UnifiedCatalogClient()
+        glossary_client = Glossary()
+        
+        # Get all domains
+        domains_result = uc_client.get_governance_domains({})
+        if isinstance(domains_result, dict):
+            domains = domains_result.get("value", [])
+        elif isinstance(domains_result, (list, tuple)):
+            domains = domains_result
+        else:
+            domains = []
+        
+        if not domains:
+            console.print("[yellow]No governance domains found.[/yellow]")
+            return
+        
+        # Get existing glossaries
+        glossaries_result = glossary_client.glossaryRead({})
+        if isinstance(glossaries_result, dict):
+            existing_glossaries = glossaries_result.get("value", [])
+        elif isinstance(glossaries_result, (list, tuple)):
+            existing_glossaries = glossaries_result
+        else:
+            existing_glossaries = []
+        
+        # Build set of domain IDs that already have glossaries (check qualifiedName)
+        existing_domain_ids = set()
+        for g in existing_glossaries:
+            if isinstance(g, dict):
+                qn = g.get("qualifiedName", "")
+                # Extract domain_id from qualifiedName if it contains @domain_id pattern
+                if "@" in qn:
+                    domain_id_part = qn.split("@")[-1]
+                    existing_domain_ids.add(domain_id_part)
+        
+        console.print(f"[cyan]Found {len(domains)} governance domains and {len(existing_glossaries)} existing glossaries[/cyan]\n")
+        
+        created_count = 0
+        for domain in domains:
+            if not isinstance(domain, dict):
+                continue
+            
+            domain_id = domain.get("id")
+            domain_name = domain.get("name")
+            
+            if not domain_id or not domain_name:
+                continue
+            
+            # Check if glossary already exists for this domain
+            if domain_id in existing_domain_ids:
+                console.print(f"[dim]⏭  Skipping {domain_name} - glossary already exists[/dim]")
+                continue
+            
+            # Create glossary for this domain
+            glossary_name = f"{domain_name} Glossary"
+            qualified_name = f"{glossary_name}@{domain_id}"
+            
+            payload = {
+                "name": glossary_name,
+                "qualifiedName": qualified_name,
+                "shortDescription": f"Glossary for {domain_name} domain",
+                "longDescription": f"This glossary contains business terms for the {domain_name} governance domain.",
+            }
+            
+            try:
+                result = glossary_client.glossaryCreate({"--payloadFile": payload})
+                guid = result.get("guid") if isinstance(result, dict) else None
+                
+                if guid:
+                    console.print(f"[green]✅ Created:[/green] {glossary_name} (GUID: {guid})")
+                    created_count += 1
+                else:
+                    console.print(f"[yellow]⚠  Created {glossary_name} but no GUID returned[/yellow]")
+                    
+            except Exception as e:
+                console.print(f"[red]❌ Failed to create {glossary_name}:[/red] {str(e)}")
+        
+        console.print(f"\n[cyan]Created {created_count} new glossaries[/cyan]")
+        console.print("[dim]Run 'pvw uc glossary list' to see all glossaries[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]ERROR:[/red] {str(e)}")
+
+
+@glossary.command(name="verify-links")
+def verify_glossary_links():
+    """Verify which domains have properly linked glossaries."""
+    try:
+        from purviewcli.client._glossary import Glossary
+        
+        uc_client = UnifiedCatalogClient()
+        glossary_client = Glossary()
+        
+        # Get all domains
+        domains_result = uc_client.get_governance_domains({})
+        if isinstance(domains_result, dict):
+            domains = domains_result.get("value", [])
+        elif isinstance(domains_result, (list, tuple)):
+            domains = domains_result
+        else:
+            domains = []
+        
+        # Get all glossaries
+        glossaries_result = glossary_client.glossaryRead({})
+        if isinstance(glossaries_result, dict):
+            glossaries = glossaries_result.get("value", [])
+        elif isinstance(glossaries_result, (list, tuple)):
+            glossaries = glossaries_result
+        else:
+            glossaries = []
+        
+        console.print(f"[bold cyan]Governance Domain → Glossary Link Verification[/bold cyan]\n")
+        
+        table = Table(title="Domain-Glossary Associations")
+        table.add_column("Domain Name", style="green")
+        table.add_column("Domain ID", style="cyan", no_wrap=True)
+        table.add_column("Linked Glossary", style="yellow")
+        table.add_column("Glossary GUID", style="magenta", no_wrap=True)
+        table.add_column("Status", style="white")
+        
+        # Build a map of domain_id -> glossary info
+        domain_glossary_map = {}
+        for g in glossaries:
+            if not isinstance(g, dict):
+                continue
+            qn = g.get("qualifiedName", "")
+            # Check if qualifiedName contains @domain_id pattern
+            if "@" in qn:
+                domain_id_part = qn.split("@")[-1]
+                domain_glossary_map[domain_id_part] = {
+                    "name": g.get("name"),
+                    "guid": g.get("guid"),
+                    "qualifiedName": qn,
+                }
+        
+        linked_count = 0
+        unlinked_count = 0
+        
+        for domain in domains:
+            if not isinstance(domain, dict):
+                continue
+            
+            domain_id = domain.get("id")
+            domain_name = domain.get("name", "N/A")
+            parent_id = domain.get("parentDomainId")
+            
+            # Skip if no domain_id
+            if not domain_id:
+                continue
+            
+            # Show if it's a nested domain
+            nested_indicator = " (nested)" if parent_id else ""
+            domain_display = f"{domain_name}{nested_indicator}"
+            
+            if domain_id in domain_glossary_map:
+                glossary_info = domain_glossary_map[domain_id]
+                table.add_row(
+                    domain_display,
+                    domain_id[:8] + "...",
+                    glossary_info["name"],
+                    glossary_info["guid"][:8] + "...",
+                    "[green]✅ Linked[/green]"
+                )
+                linked_count += 1
+            else:
+                table.add_row(
+                    domain_display,
+                    domain_id[:8] + "...",
+                    "[dim]No glossary[/dim]",
+                    "[dim]N/A[/dim]",
+                    "[yellow]⚠ Not Linked[/yellow]"
+                )
+                unlinked_count += 1
+        
+        console.print(table)
+        console.print(f"\n[cyan]Summary:[/cyan]")
+        console.print(f"  • Linked domains: [green]{linked_count}[/green]")
+        console.print(f"  • Unlinked domains: [yellow]{unlinked_count}[/yellow]")
+        
+        if unlinked_count > 0:
+            console.print(f"\n[dim]💡 Tip: Run 'pvw uc glossary create-for-domains' to create glossaries for unlinked domains[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]ERROR:[/red] {str(e)}")
+
+
 # ========================================
 # GLOSSARY TERMS
 # ========================================
 
+
 @uc.group()
 def term():
     """Manage glossary terms."""
@@ -336,119 +770,204 @@ def term():
 @click.option("--name", required=True, help="Name of the glossary term")
 @click.option("--description", required=False, default="", help="Rich text description of the term")
 @click.option("--domain-id", required=True, help="Governance domain ID")
-@click.option("--status", required=False, default="Draft", 
-              type=click.Choice(["Draft", "Published", "Archived"]),
-              help="Status of the term")
-@click.option("--acronym", required=False, help="Acronyms for the term (can be specified multiple times)", multiple=True)
-@click.option("--owner-id", required=False, help="Owner Entra ID (can be specified multiple times)", multiple=True)
-@click.option("--resource-name", required=False, help="Resource name for additional reading")
-@click.option("--resource-url", required=False, help="Resource URL for additional reading")
+@click.option(
+    "--status",
+    required=False,
+    default="Draft",
+    type=click.Choice(["Draft", "Published", "Archived"]),
+    help="Status of the term",
+)
+@click.option(
+    "--acronym",
+    required=False,
+    help="Acronyms for the term (can be specified multiple times)",
+    multiple=True,
+)
+@click.option(
+    "--owner-id",
+    required=False,
+    help="Owner Entra ID (can be specified multiple times)",
+    multiple=True,
+)
+@click.option("--resource-name", required=False, help="Resource name for additional reading (can be specified multiple times)", multiple=True)
+@click.option("--resource-url", required=False, help="Resource URL for additional reading (can be specified multiple times)", multiple=True)
 def create(name, description, domain_id, status, acronym, owner_id, resource_name, resource_url):
-    """Create a new glossary term."""
+    """Create a new Unified Catalog term (Governance Domain term)."""
     try:
         client = UnifiedCatalogClient()
-        
+
         # Build args dictionary
         args = {
             "--name": [name],
             "--description": [description],
             "--governance-domain-id": [domain_id],
-            "--status": [status]
+            "--status": [status],
         }
-        
+
         if acronym:
-            args["--acronyms"] = list(acronym)
+            args["--acronym"] = list(acronym)
         if owner_id:
             args["--owner-id"] = list(owner_id)
-        if resource_name and resource_url:
-            args["--resource-name"] = [resource_name]
-            args["--resource-url"] = [resource_url]
-            
+        if resource_name:
+            args["--resource-name"] = list(resource_name)
+        if resource_url:
+            args["--resource-url"] = list(resource_url)
+
         result = client.create_term(args)
-        
+
         if not result:
             console.print("[red]ERROR:[/red] No response received")
             return
         if isinstance(result, dict) and "error" in result:
             console.print(f"[red]ERROR:[/red] {result.get('error', 'Unknown error')}")
             return
-            
+
         console.print(f"[green]✅ SUCCESS:[/green] Created glossary term '{name}'")
         console.print(json.dumps(result, indent=2))
-        
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
 
 @term.command(name="list")
 @click.option("--domain-id", required=True, help="Governance domain ID to list terms from")
-def list_terms(domain_id):
-    """List all glossary terms in a governance domain."""
+@click.option("--json", "output_json", is_flag=True, help="Output results in JSON format")
+def list_terms(domain_id, output_json):
+    """List all Unified Catalog terms in a governance domain."""
     try:
         client = UnifiedCatalogClient()
         args = {"--governance-domain-id": [domain_id]}
         result = client.get_terms(args)
-        
+
         if not result:
-            console.print("[yellow]No glossary terms found.[/yellow]")
+            console.print("[yellow]No terms found.[/yellow]")
             return
-            
-        # Handle both list and dict responses
-        if isinstance(result, (list, tuple)):
-            terms = result
-        elif isinstance(result, dict):
-            terms = result.get("value", [])
+
+        # Unified Catalog API returns terms directly in value array
+        all_terms = []
+
+        if isinstance(result, dict):
+            all_terms = result.get("value", [])
+        elif isinstance(result, (list, tuple)):
+            all_terms = result
         else:
-            terms = []
-            
-        if not terms:
-            console.print("[yellow]No glossary terms found.[/yellow]")
+            console.print("[yellow]Unexpected response format.[/yellow]")
             return
-            
-        table = Table(title="Glossary Terms")
-        table.add_column("ID", style="cyan")
+
+        if not all_terms:
+            console.print("[yellow]No terms found.[/yellow]")
+            return
+
+        # Output in JSON format if requested
+        if output_json:
+            _format_json_output(all_terms)
+            return
+
+        table = Table(title="Unified Catalog Terms")
+        table.add_column("Term ID", style="cyan", no_wrap=False)
         table.add_column("Name", style="green")
-        table.add_column("Status", style="yellow") 
-        table.add_column("Acronyms", style="blue")
+        table.add_column("Status", style="yellow")
         table.add_column("Description", style="white")
-        
-        for term in terms:
-            acronyms = ", ".join(term.get("acronyms", []))
-            desc = term.get("description", "")
-            if len(desc) > 50:
-                desc = desc[:50] + "..."
-                
+
+        for term in all_terms:
+            description = term.get("description", "")
+            # Strip HTML tags from description
+            import re
+            description = re.sub(r'<[^>]+>', '', description)
+            # Truncate long descriptions
+            if len(description) > 50:
+                description = description[:50] + "..."
+            
             table.add_row(
                 term.get("id", "N/A"),
                 term.get("name", "N/A"),
                 term.get("status", "N/A"),
-                acronyms or "None",
-                desc
+                description.strip(),
             )
-            
+
         console.print(table)
-        
+        console.print(f"\n[dim]Found {len(all_terms)} term(s)[/dim]")
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
 
 @term.command()
 @click.option("--term-id", required=True, help="ID of the glossary term")
-def show(term_id):
+@click.option("--json", "output_json", is_flag=True, help="Output results in JSON format")
+def show(term_id, output_json):
     """Show details of a glossary term."""
     try:
         client = UnifiedCatalogClient()
         args = {"--term-id": [term_id]}
         result = client.get_term_by_id(args)
-        
+
         if not result:
             console.print("[red]ERROR:[/red] No response received")
             return
         if isinstance(result, dict) and "error" in result:
             console.print(f"[red]ERROR:[/red] {result.get('error', 'Term not found')}")
             return
+
+        if output_json:
+            _format_json_output(result)
+        else:
+            # Display key information in a readable format
+            if isinstance(result, dict):
+                console.print(f"[cyan]Term Name:[/cyan] {result.get('name', 'N/A')}")
+                console.print(f"[cyan]GUID:[/cyan] {result.get('guid', 'N/A')}")
+                console.print(f"[cyan]Status:[/cyan] {result.get('status', 'N/A')}")
+                console.print(f"[cyan]Qualified Name:[/cyan] {result.get('qualifiedName', 'N/A')}")
+                
+                # Show glossary info
+                anchor = result.get('anchor', {})
+                if anchor:
+                    console.print(f"[cyan]Glossary GUID:[/cyan] {anchor.get('glossaryGuid', 'N/A')}")
+                
+                # Show description
+                desc = result.get('shortDescription') or result.get('longDescription', '')
+                if desc:
+                    console.print(f"[cyan]Description:[/cyan] {desc}")
+                
+                # Show full JSON if needed
+                console.print(f"\n[dim]Full details (JSON):[/dim]")
+                console.print(json.dumps(result, indent=2))
+            else:
+                console.print(json.dumps(result, indent=2))
+
+    except Exception as e:
+        console.print(f"[red]ERROR:[/red] {str(e)}")
+
+
+@term.command()
+@click.option("--term-id", required=True, help="ID of the glossary term to delete")
+@click.option("--force", is_flag=True, help="Skip confirmation prompt")
+def delete(term_id, force):
+    """Delete a glossary term."""
+    try:
+        if not force:
+            # Show term details first
+            client = UnifiedCatalogClient()
+            term_info = client.get_term_by_id({"--term-id": [term_id]})
             
-        console.print(json.dumps(result, indent=2))
+            if isinstance(term_info, dict) and term_info.get('name'):
+                console.print(f"[yellow]About to delete term:[/yellow]")
+                console.print(f"  Name: {term_info.get('name')}")
+                console.print(f"  GUID: {term_info.get('guid')}")
+                console.print(f"  Status: {term_info.get('status')}")
+            
+            confirm = click.confirm("Are you sure you want to delete this term?", default=False)
+            if not confirm:
+                console.print("[yellow]Deletion cancelled.[/yellow]")
+                return
+        
+        # Import glossary client to delete term
+        from purviewcli.client._glossary import Glossary
+        
+        gclient = Glossary()
+        result = gclient.glossaryDeleteTerm({"--termGuid": term_id})
+        
+        console.print(f"[green]✅ SUCCESS:[/green] Deleted term with ID: {term_id}")
         
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
@@ -458,6 +977,7 @@ def show(term_id):
 # OBJECTIVES AND KEY RESULTS (OKRs)
 # ========================================
 
+
 @uc.group()
 def objective():
     """Manage objectives and key results (OKRs)."""
@@ -467,56 +987,68 @@ def objective():
 @objective.command()
 @click.option("--definition", required=True, help="Definition of the objective")
 @click.option("--domain-id", required=True, help="Governance domain ID")
-@click.option("--status", required=False, default="Draft",
-              type=click.Choice(["Draft", "Published", "Archived"]),
-              help="Status of the objective")
-@click.option("--owner-id", required=False, help="Owner Entra ID (can be specified multiple times)", multiple=True)
-@click.option("--target-date", required=False, help="Target date (ISO format: 2025-12-30T14:00:00.000Z)")
+@click.option(
+    "--status",
+    required=False,
+    default="Draft",
+    type=click.Choice(["Draft", "Published", "Archived"]),
+    help="Status of the objective",
+)
+@click.option(
+    "--owner-id",
+    required=False,
+    help="Owner Entra ID (can be specified multiple times)",
+    multiple=True,
+)
+@click.option(
+    "--target-date", required=False, help="Target date (ISO format: 2025-12-30T14:00:00.000Z)"
+)
 def create(definition, domain_id, status, owner_id, target_date):
     """Create a new objective."""
     try:
         client = UnifiedCatalogClient()
-        
+
         args = {
             "--definition": [definition],
             "--governance-domain-id": [domain_id],
-            "--status": [status]
+            "--status": [status],
         }
-        
+
         if owner_id:
             args["--owner-id"] = list(owner_id)
         if target_date:
             args["--target-date"] = [target_date]
-            
+
         result = client.create_objective(args)
-        
+
         if not result:
             console.print("[red]ERROR:[/red] No response received")
             return
         if isinstance(result, dict) and "error" in result:
             console.print(f"[red]ERROR:[/red] {result.get('error', 'Unknown error')}")
             return
-            
+
         console.print(f"[green]✅ SUCCESS:[/green] Created objective")
         console.print(json.dumps(result, indent=2))
-        
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
 
 @objective.command(name="list")
 @click.option("--domain-id", required=True, help="Governance domain ID to list objectives from")
-def list_objectives(domain_id):
+@click.option("--json", "output_json", is_flag=True, help="Output results in JSON format")
+def list_objectives(domain_id, output_json):
     """List all objectives in a governance domain."""
     try:
         client = UnifiedCatalogClient()
         args = {"--governance-domain-id": [domain_id]}
         result = client.get_objectives(args)
-        
+
         if not result:
             console.print("[yellow]No objectives found.[/yellow]")
             return
-            
+
         # Handle response format
         if isinstance(result, (list, tuple)):
             objectives = result
@@ -524,31 +1056,36 @@ def list_objectives(domain_id):
             objectives = result.get("value", [])
         else:
             objectives = []
-            
+
         if not objectives:
             console.print("[yellow]No objectives found.[/yellow]")
             return
-            
+
+        # Output in JSON format if requested
+        if output_json:
+            _format_json_output(objectives)
+            return
+
         table = Table(title="Objectives")
         table.add_column("ID", style="cyan")
         table.add_column("Definition", style="green")
         table.add_column("Status", style="yellow")
         table.add_column("Target Date", style="blue")
-        
+
         for obj in objectives:
             definition = obj.get("definition", "")
             if len(definition) > 50:
                 definition = definition[:50] + "..."
-                
+
             table.add_row(
                 obj.get("id", "N/A"),
                 definition,
                 obj.get("status", "N/A"),
-                obj.get("targetDate", "N/A")
+                obj.get("targetDate", "N/A"),
             )
-            
+
         console.print(table)
-        
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
@@ -561,16 +1098,16 @@ def show(objective_id):
         client = UnifiedCatalogClient()
         args = {"--objective-id": [objective_id]}
         result = client.get_objective_by_id(args)
-        
+
         if not result:
             console.print("[red]ERROR:[/red] No response received")
             return
         if isinstance(result, dict) and "error" in result:
             console.print(f"[red]ERROR:[/red] {result.get('error', 'Objective not found')}")
             return
-            
+
         console.print(json.dumps(result, indent=2))
-        
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
@@ -579,6 +1116,7 @@ def show(objective_id):
 # CRITICAL DATA ELEMENTS (CDEs)
 # ========================================
 
+
 @uc.group()
 def cde():
     """Manage critical data elements."""
@@ -589,58 +1127,71 @@ def cde():
 @click.option("--name", required=True, help="Name of the critical data element")
 @click.option("--description", required=False, default="", help="Description of the CDE")
 @click.option("--domain-id", required=True, help="Governance domain ID")
-@click.option("--data-type", required=True,
-              type=click.Choice(["String", "Number", "Boolean", "Date", "DateTime"]),
-              help="Data type of the CDE")
-@click.option("--status", required=False, default="Draft",
-              type=click.Choice(["Draft", "Published", "Archived"]),
-              help="Status of the CDE")
-@click.option("--owner-id", required=False, help="Owner Entra ID (can be specified multiple times)", multiple=True)
+@click.option(
+    "--data-type",
+    required=True,
+    type=click.Choice(["String", "Number", "Boolean", "Date", "DateTime"]),
+    help="Data type of the CDE",
+)
+@click.option(
+    "--status",
+    required=False,
+    default="Draft",
+    type=click.Choice(["Draft", "Published", "Archived"]),
+    help="Status of the CDE",
+)
+@click.option(
+    "--owner-id",
+    required=False,
+    help="Owner Entra ID (can be specified multiple times)",
+    multiple=True,
+)
 def create(name, description, domain_id, data_type, status, owner_id):
     """Create a new critical data element."""
     try:
         client = UnifiedCatalogClient()
-        
+
         args = {
             "--name": [name],
             "--description": [description],
             "--governance-domain-id": [domain_id],
             "--data-type": [data_type],
-            "--status": [status]
+            "--status": [status],
         }
-        
+
         if owner_id:
             args["--owner-id"] = list(owner_id)
-            
+
         result = client.create_critical_data_element(args)
-        
+
         if not result:
             console.print("[red]ERROR:[/red] No response received")
             return
         if isinstance(result, dict) and "error" in result:
             console.print(f"[red]ERROR:[/red] {result.get('error', 'Unknown error')}")
             return
-            
+
         console.print(f"[green]✅ SUCCESS:[/green] Created critical data element '{name}'")
         console.print(json.dumps(result, indent=2))
-        
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
 
 @cde.command(name="list")
 @click.option("--domain-id", required=True, help="Governance domain ID to list CDEs from")
-def list_cdes(domain_id):
+@click.option("--json", "output_json", is_flag=True, help="Output results in JSON format")
+def list_cdes(domain_id, output_json):
     """List all critical data elements in a governance domain."""
     try:
         client = UnifiedCatalogClient()
         args = {"--governance-domain-id": [domain_id]}
         result = client.get_critical_data_elements(args)
-        
+
         if not result:
             console.print("[yellow]No critical data elements found.[/yellow]")
             return
-            
+
         # Handle response format
         if isinstance(result, (list, tuple)):
             cdes = result
@@ -648,33 +1199,38 @@ def list_cdes(domain_id):
             cdes = result.get("value", [])
         else:
             cdes = []
-            
+
         if not cdes:
             console.print("[yellow]No critical data elements found.[/yellow]")
             return
-            
+
+        # Output in JSON format if requested
+        if output_json:
+            _format_json_output(cdes)
+            return
+
         table = Table(title="Critical Data Elements")
         table.add_column("ID", style="cyan")
         table.add_column("Name", style="green")
         table.add_column("Data Type", style="blue")
         table.add_column("Status", style="yellow")
         table.add_column("Description", style="white")
-        
+
         for cde_item in cdes:
             desc = cde_item.get("description", "")
             if len(desc) > 30:
                 desc = desc[:30] + "..."
-                
+
             table.add_row(
                 cde_item.get("id", "N/A"),
                 cde_item.get("name", "N/A"),
                 cde_item.get("dataType", "N/A"),
                 cde_item.get("status", "N/A"),
-                desc
+                desc,
             )
-            
+
         console.print(table)
-        
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
@@ -687,55 +1243,34 @@ def show(cde_id):
         client = UnifiedCatalogClient()
         args = {"--cde-id": [cde_id]}
         result = client.get_critical_data_element_by_id(args)
-        
+
         if not result:
             console.print("[red]ERROR:[/red] No response received")
             return
         if isinstance(result, dict) and "error" in result:
             console.print(f"[red]ERROR:[/red] {result.get('error', 'CDE not found')}")
             return
-            
+
         console.print(json.dumps(result, indent=2))
-        
+
     except Exception as e:
         console.print(f"[red]ERROR:[/red] {str(e)}")
 
 
 # ========================================
-# HEALTH MANAGEMENT (Preview)
+# HEALTH MANAGEMENT - IMPLEMENTED! ✅
 # ========================================
 
-@uc.group()
-def health():
-    """Manage health controls and actions (preview)."""
-    pass
-
-
-@health.command(name="controls")
-def list_controls():
-    """List health controls (preview - not yet implemented)."""
-    console.print("[yellow]🚧 Health Controls are not yet implemented in the API[/yellow]")
-    console.print("This feature is coming soon to Microsoft Purview Unified Catalog")
-
-
-@health.command(name="actions") 
-def list_actions():
-    """List health actions (preview - not yet implemented)."""
-    console.print("[yellow]🚧 Health Actions are not yet implemented in the API[/yellow]")
-    console.print("This feature is coming soon to Microsoft Purview Unified Catalog")
-
-
-@health.command(name="quality")
-def data_quality():
-    """Data quality management (not yet supported by API)."""
-    console.print("[yellow]🚧 Data Quality management is not yet supported by the API[/yellow]")
-    console.print("This feature requires complex API interactions not yet available")
+# Import and register health commands from dedicated module
+from purviewcli.cli.health import health as health_commands
+uc.add_command(health_commands, name="health")
 
 
 # ========================================
 # CUSTOM ATTRIBUTES (Coming Soon)
 # ========================================
 
+
 @uc.group()
 def attribute():
     """Manage custom attributes (coming soon)."""
@@ -753,6 +1288,7 @@ def list_attributes():
 # REQUESTS (Coming Soon)
 # ========================================
 
+
 @uc.group()
 def request():
     """Manage access requests (coming soon)."""
@@ -763,4 +1299,4 @@ def request():
 def list_requests():
     """List access requests (coming soon)."""
     console.print("[yellow]🚧 Access Requests are coming soon[/yellow]")
-    console.print("This feature is under development for data access workflows")
+    console.print("This feature is under development for data access workflows")