acex-cli 4.1.2__tar.gz → 4.2.0__tar.gz

{acex_cli-4.1.2 → acex_cli-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acex-cli
-Version: 4.1.2
+Version: 4.2.0
 Summary: ACE-X CLI - Command-line interface for ACE-X
 License: AGPL-3.0
 Keywords: automation,cli,control
@@ -11,8 +11,8 @@ Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: acex-client (>=4.1.2,<5.0.0)
-Requires-Dist: acex-driver-cisco-ioscli (>=0.0.12,<0.0.13)
+Requires-Dist: acex-client (>=4.2.0,<5.0.0)
+Requires-Dist: acex-driver-cisco-ioscli (>=0.0.17,<0.0.18)
 Requires-Dist: click (==8.1.7)
 Requires-Dist: ntc-templates (>=8.1.0,<9.0.0)
 Requires-Dist: rich (>=13.0.0,<14.0.0)

{acex_cli-4.1.2 → acex_cli-4.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "acex-cli"
-version = "4.1.2"
+version = "4.2.0"
 description = "ACE-X CLI - Command-line interface for ACE-X"
 authors = ["Johan Lahti <johan.lahti@acebit.se>"]
 readme = "README.md"
@@ -17,8 +17,8 @@ python = "^3.13"
 typer = "^0.12.0"
 rich = "^13.0.0"
 click = "8.1.7"
-acex-client = "^4.1.2" # Changes to real dep. by switch_acex_client_dep for publishing
-acex-driver-cisco-ioscli = "^0.0.12"
+acex-client = "^4.2.0" # Changes to real dep. by switch_acex_client_dep for publishing
+acex-driver-cisco-ioscli = "^0.0.17"
 ntc-templates = "^8.1.0"
 
 [tool.poetry.scripts]

{acex_cli-4.1.2 → acex_cli-4.2.0}/src/acex_cli/commands/node.py

@@ -8,7 +8,7 @@ import requests
 import typer
 
 from acex_cli.sdk import get_sdk
-from acex_cli.print_utils import print_list_table, print_object
+from acex_cli.print_utils import print_list_table, print_object, print_commands_box
 from acex_client.models.generated_models import Node
 
 from acex_devkit.models.composed_configuration import ComposedConfiguration
@@ -29,6 +29,10 @@ def _request_get(sdk, path: str, params: Optional[dict] = None) -> requests.Resp
     response.raise_for_status()
     return response
 
+def _get_connection(sdk, node_id):
+    response = _request_get(sdk, f"/inventory/management_connections/?node_id={node_id}")
+    return response.json()
+
 
 def _get_rendered_config(sdk, node_id: str) -> str:
     response = _request_get(sdk, f"/inventory/node_instances/{node_id}/config")
@@ -249,7 +253,8 @@ def show_diff_plan(
         dfg = observed_config
         d = diff
         ned = sdk.neds.get_driver_instance(node_instance.asset.ned_id)
-        commands = ned.jusify_diff_commands(observed_config, d, node_instance.asset) 
+        # commands = ned.jusify_diff_commands(observed_config, d, node_instance.asset) 
+        commands = ned.render_patch(d, node_instance) 
 
         print(commands)
     else:
@@ -258,171 +263,54 @@ def show_diff_plan(
 
 
 
-
-
-
-
-
-
-
-
-
-
-
+####################################################################
 
 # acex node config diff {from} {to} 
 
 ####################################################################
 
+# NODE CONFIG APPLY COMMANDS
+@config_diff_app.command("apply") 
+def show_diff_plan(
+    ctx: typer.Context,
+    node_id: str,
+):
+    
+    sdk = get_sdk(ctx.obj.get_active_context())
+    differ = sdk.differ
+    
+    # Fetch observed config
+    observed_config = _get_latest_observed_config(sdk, node_id, "parsed").get("content")
+    observed_config = ComposedConfiguration(**observed_config)
 
 
+    # Fetch desired config
+    node_instance = sdk.node_instances.get(node_id)
+    if not node_instance:
+        typer.echo("Node instance not found.")
+        return
 
+    logical_node = sdk.logical_nodes.get(node_instance.logical_node_id)
+    if not logical_node:
+        typer.echo("Logical node not found.")
+        return
 
+    desired_config = getattr(logical_node, "configuration", None)
+    if desired_config is None:
+        typer.echo("No desired configuration found.")
+        return
 
+    diff = differ.diff(observed_config=observed_config, desired_config=desired_config)
+    ned = sdk.neds.get_driver_instance(node_instance.asset.ned_id)
 
+    commands = ned.render_patch(diff, node_instance)
+    print_commands_box(commands, node_id)
+    proceed = typer.confirm(f"Are you sure you want to apply the config above?")
 
+    if not proceed:
+        exit()
 
+    connection = _get_connection(sdk, node_id)
 
-
-# @config_diff_app.command("observed")
-# def observed_config_diff(
-#     ctx: typer.Context,
-#     node_id: str,
-#     diff_from: Optional[str] = typer.Option(
-#         None, "--from-hash", help="Diff from this backup hash"
-#     ),
-#     diff_to: Optional[str] = typer.Option(
-#         None, "--to-hash", help="Diff to this backup hash"
-#     ),
-#     diff_from_time: Optional[str] = typer.Option(
-#         None,
-#         "--from-time",
-#         help="Diff from latest backup at or before this timestamp (ISO 8601)",
-#     ),
-#     diff_to_time: Optional[str] = typer.Option(
-#         None,
-#         "--to-time",
-#         help="Diff to latest backup at or before this timestamp (ISO 8601)",
-#     ),
-# ):
-#     """Diff observed (backup) configs between two hashes."""
-#     sdk = get_sdk(ctx.obj.get_active_context())
-
-#     using_hashes = diff_from is not None and diff_to is not None
-#     using_times = diff_from_time is not None and diff_to_time is not None
-
-#     if using_hashes and using_times:
-#         typer.echo("Use either --from-hash/--to-hash or --from-time/--to-time, not both.")
-#         raise typer.Exit(code=2)
-
-#     if not using_hashes and not using_times:
-#         typer.echo("Provide --from-hash/--to-hash or --from-time/--to-time.")
-#         raise typer.Exit(code=2)
-
-#     if using_times:
-#         left = _get_observed_config_before(sdk, node_id, diff_from_time)
-#         right = _get_observed_config_before(sdk, node_id, diff_to_time)
-#         left_hash = left.get("hash") if isinstance(left, dict) else None
-#         right_hash = right.get("hash") if isinstance(right, dict) else None
-#         from_label = (
-#             f"{node_id}:observed@{diff_from_time}"
-#             f"{f'#{left_hash}' if left_hash else ''}"
-#         )
-#         to_label = (
-#             f"{node_id}:observed@{diff_to_time}"
-#             f"{f'#{right_hash}' if right_hash else ''}"
-#         )
-#     else:
-#         left = _get_observed_config_by_hash(sdk, node_id, diff_from)
-#         right = _get_observed_config_by_hash(sdk, node_id, diff_to)
-#         from_label = f"{node_id}:{diff_from}"
-#         to_label = f"{node_id}:{diff_to}"
-
-#     if not left or not right:
-#         typer.echo("Observed config not found for one or both inputs.")
-#         return
-
-#     left_content = left.get("content") if isinstance(left, dict) else None
-#     right_content = right.get("content") if isinstance(right, dict) else None
-
-#     if left_content is None or right_content is None:
-#         typer.echo("Observed config content missing for one or both hashes.")
-#         return
-
-#     left_text = _decode_config_content(left_content).splitlines(keepends=True)
-#     right_text = _decode_config_content(right_content).splitlines(keepends=True)
-
-#     diff = difflib.unified_diff(
-#         left_text,
-#         right_text,
-#         fromfile=from_label,
-#         tofile=to_label,
-#     )
-#     typer.echo("".join(diff))
-
-
-# @config_diff_app.command("desired-observed")
-# def desired_observed_diff(
-#     ctx: typer.Context,
-#     node_id: str,
-#     config_hash: Optional[str] = typer.Option(
-#         None, "--hash", help="Diff against a specific observed backup hash"
-#     ),
-#     point_in_time: Optional[str] = typer.Option(
-#         None,
-#         "--time",
-#         help="Diff against latest observed backup at or before this timestamp (ISO 8601)",
-#     ),
-# ):
-#     """Diff desired config against observed (backup) config."""
-#     sdk = get_sdk(ctx.obj.get_active_context())
-
-#     if config_hash and point_in_time:
-#         typer.echo("Use either --hash or --time, not both.")
-#         raise typer.Exit(code=2)
-
-#     desired = _get_rendered_config(sdk, node_id)
-#     if config_hash:
-#         observed = _get_observed_config_by_hash(sdk, node_id, config_hash)
-#         observed_label = f"{node_id}:observed@{config_hash}"
-#     elif point_in_time:
-#         observed = _get_observed_config_before(sdk, node_id, point_in_time)
-#         observed_label = f"{node_id}:observed@{point_in_time}"
-#     else:
-#         observed = _get_latest_observed_config(sdk, node_id)
-#         observed_label = f"{node_id}:observed"
-
-#     if not observed:
-#         typer.echo("No observed config found.")
-#         return
-
-#     content = observed.get("content") if isinstance(observed, dict) else None
-#     if content is None:
-#         typer.echo("Observed config has no content.")
-#         return
-
-#     observed_text = _decode_config_content(content)
-#     diff = difflib.unified_diff(
-#         desired.splitlines(keepends=True),
-#         observed_text.splitlines(keepends=True),
-#         fromfile=f"{node_id}:desired",
-#         tofile=observed_label,
-#     )
-#     typer.echo("".join(diff))
-
-
-# @config_app.command("observed-list")
-# def observed_config_list(ctx: typer.Context, node_id: str):
-#     """List observed config backups for a node instance."""
-#     sdk = get_sdk(ctx.obj.get_active_context())
-#     backups = _list_observed_config_hashes(sdk, node_id)
-#     if not backups:
-#         typer.echo("No observed config backups found.")
-#         return
-
-#     print_list_table(
-#         backups,
-#         columns=["id", "hash", "created_at", "node_instance_id"],
-#         title=f"Observed config backups for node {node_id}",
-#     )
+    ned.apply_patch(diff, node_instance, connection[0].get("target_ip"))
 

acex_cli-4.2.0/src/acex_cli/diff_formatters.py

@@ -0,0 +1,345 @@
+"""Formatters for displaying configuration diffs in CLI."""
+import json
+from rich.tree import Tree
+from rich.text import Text
+from rich.table import Table
+from rich.console import Console
+
+console = Console()
+
+from pydantic import BaseModel
+from acex_devkit.configdiffer import Diff, ComponentDiffOp
+
+
+def _as_dict(obj) -> dict:
+    """Convert a Pydantic model or dict to a plain dict for iteration."""
+    if isinstance(obj, BaseModel):
+        return obj.model_dump()
+    if isinstance(obj, dict):
+        return obj
+    return {}
+
+
+def print_diff_summary(diff):
+    """Print a summary of the diff statistics."""
+    
+    if not isinstance(diff, Diff):
+        console.print("[red]Invalid diff object[/red]")
+        return
+    
+    if diff.is_empty():
+        console.print("[green]✓ No changes detected[/green]")
+        return
+    
+    summary = diff.summary()
+    
+    table = Table(title="Configuration Diff Summary")
+    table.add_column("Operation", style="bold")
+    table.add_column("Count", style="cyan", justify="right")
+    
+    if summary.get("added", 0) > 0:
+        table.add_row("Added", f"[green]{summary['added']}[/green]")
+    if summary.get("removed", 0) > 0:
+        table.add_row("Removed", f"[red]{summary['removed']}[/red]")
+    if summary.get("changed", 0) > 0:
+        table.add_row("Changed", f"[yellow]{summary['changed']}[/yellow]")
+    
+    console.print(table)
+
+
+def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
+    """
+    Print diff as a hierarchical tree view.
+    
+    Args:
+        diff: Diff object from configdiffer
+        max_depth: Maximum depth to show (None for unlimited)
+        show_values: Whether to show before/after values
+    """
+    
+    if not isinstance(diff, Diff):
+        console.print("[red]Invalid diff object[/red]")
+        return
+    
+    if diff.is_empty():
+        console.print("[green]✓ No changes detected[/green]")
+        return
+    
+    # Create colored title with summary
+    summary = diff.summary()
+    title = Text("🔀 Configuration Changes ", style="bold")
+    title.append("(", style="dim")
+    
+    parts = []
+    if summary.get("added", 0) > 0:
+        parts.append((f"+{summary['added']}", "green"))
+    if summary.get("removed", 0) > 0:
+        parts.append((f"-{summary['removed']}", "red"))
+    if summary.get("changed", 0) > 0:
+        parts.append((f"~{summary['changed']}", "yellow"))
+    
+    for i, (text, color) in enumerate(parts):
+        if i > 0:
+            title.append(" ", style="dim")
+        title.append(text, style=f"bold {color}")
+    
+    title.append(")", style="dim")
+    
+    tree = Tree(title)
+    
+    # Build a hierarchical tree structure based on component paths
+    # We'll use a dict to track nodes: path_tuple -> tree_node
+    path_nodes = {}
+    
+    # Group changes by top-level section first to get counts
+    sections = {}
+    for change in diff.get_all_changes():
+        section = change.path[0] if change.path else "root"
+        if section not in sections:
+            sections[section] = []
+        sections[section].append(change)
+    
+    # Process each change and build nested structure
+    for section_name in sorted(sections.keys()):
+        section_changes = sections[section_name]
+        
+        # Create section node
+        section_label = Text()
+        section_label.append(section_name, style="bold cyan")
+        section_label.append(f" ({len(section_changes)} changes)", style="dim")
+        section_node = tree.add(section_label)
+        path_nodes[(section_name,)] = section_node
+        
+        # Add each change, building nested path structure
+        for change in section_changes:
+            # Build path incrementally
+            path = tuple(change.path)
+            
+            # Find or create parent nodes for nested path
+            parent_node = section_node
+            for i in range(1, len(path)):
+                partial_path = path[:i+1]
+                
+                # Check if this is the final component or an intermediate path
+                if i == len(path) - 1:
+                    # This is the actual component with the change
+                    if change.op == ComponentDiffOp.ADD:
+                        style = "green"
+                        prefix = "+ "
+                    elif change.op == ComponentDiffOp.REMOVE:
+                        style = "red"
+                        prefix = "- "
+                    else:  # CHANGE
+                        style = "yellow"
+                        prefix = "~ "
+                    
+                    # Component label
+                    comp_label = Text()
+                    comp_label.append(prefix, style=f"bold {style}")
+                    comp_label.append(f"{change.component_type}: ", style=f"dim {style}")
+                    comp_label.append(change.component_name, style=style)
+                    
+                    comp_node = parent_node.add(comp_label)
+                    
+                    if show_values:
+                        # Show attributes for ADD operations
+                        if change.op == ComponentDiffOp.ADD and change.after_dict:
+                            for attr_name, attr_value in change.after_dict.items():
+                                # Skip metadata and type fields
+                                if attr_name in ['metadata', 'type']:
+                                    continue
+                                attr_label = Text()
+                                attr_label.append("  ", style="dim")
+                                attr_label.append(attr_name, style="cyan")
+                                attr_label.append(": ", style="dim")
+                                formatted_val = _format_value(attr_value)
+                                attr_label.append(formatted_val, style="dim green" if formatted_val == "null" else "green")
+                                comp_node.add(attr_label)
+                        
+                        # Show attributes for REMOVE operations
+                        elif change.op == ComponentDiffOp.REMOVE and change.before_dict:
+                            for attr_name, attr_value in change.before_dict.items():
+                                # Skip metadata and type fields
+                                if attr_name in ['metadata', 'type']:
+                                    continue
+                                attr_label = Text()
+                                attr_label.append("  ", style="dim")
+                                attr_label.append(attr_name, style="cyan")
+                                attr_label.append(": ", style="dim")
+                                formatted_val = _format_value(attr_value)
+                                attr_label.append(formatted_val, style="dim red" if formatted_val == "null" else "red")
+                                comp_node.add(attr_label)
+                        
+                        # Show changed attributes for CHANGE operations
+                        elif change.op == ComponentDiffOp.CHANGE and change.changed_attributes:
+                            for attr in change.changed_attributes:
+                                attr_label = Text()
+                                attr_label.append("  ", style="dim")
+                                attr_label.append(attr.attribute_name, style="cyan")
+                                attr_label.append(": ", style="dim")
+                                before_val = _format_value(attr.before)
+                                attr_label.append(before_val, style="dim red" if before_val == "null" else "red")
+                                attr_label.append(" → ", style="dim")
+                                after_val = _format_value(attr.after)
+                                attr_label.append(after_val, style="dim green" if after_val == "null" else "green")
+                                comp_node.add(attr_label)
+                else:
+                    # Intermediate path element - create if doesn't exist
+                    if partial_path not in path_nodes:
+                        path_label = Text()
+                        path_label.append(path[i], style="dim cyan")
+                        path_node = parent_node.add(path_label)
+                        path_nodes[partial_path] = path_node
+                    parent_node = path_nodes[partial_path]
+    
+    console.print(tree)
+
+
+def print_diff_compact(diff, show_unchanged: bool = False):
+    """
+    Print diff in a compact, git-like format.
+    
+    Args:
+        diff: Diff object from configdiffer
+        show_unchanged: Whether to show unchanged paths
+    """
+    
+    if not isinstance(diff, Diff):
+        console.print("[red]Invalid diff object[/red]")
+        return
+    
+    if diff.is_empty():
+        console.print("[green]✓ No changes detected[/green]")
+        return
+    
+    if diff.added:
+        console.print("\n[bold green]✚ Added:[/bold green]")
+        for change in diff.added:
+            path = change.get_path_str()
+            console.print(f"  [green]+ {change.component_type_name_name}:[/green] {change.component_name}")
+    
+    if diff.removed:
+        console.print("\n[bold red]✖ Removed:[/bold red]")
+        for change in diff.removed:
+            path = change.get_path_str()
+            console.print(f"  [red]- {change.component_type_name_name}:[/red] {change.component_name}")
+    
+    if diff.changed:
+        console.print("\n[bold yellow]⚡ Modified:[/bold yellow]")
+        for change in diff.changed:
+            console.print(f"  [yellow]~ {change.component_type_name_name}:[/yellow] {change.component_name}")
+            if change.changed_attributes:
+                for attr in change.changed_attributes:
+                    before_str = _format_value(attr.before, max_length=40)
+                    after_str = _format_value(attr.after, max_length=40)
+                    console.print(f"    {attr.attribute_name}:")
+                    console.print(f"      [red]- {before_str}[/red]")
+                    console.print(f"      [green]+ {after_str}[/green]")
+
+
+def print_diff_flat(diff):
+    """
+    Print diff in a flat list format, good for quick scanning.
+    
+    Args:
+        diff: Diff object from configdiffer
+    """
+    
+    if not isinstance(diff, Diff):
+        console.print("[red]Invalid diff object[/red]")
+        return
+    
+    if diff.is_empty():
+        console.print("[green]✓ No changes detected[/green]")
+        return
+    
+    # Create table
+    table = Table(title="Configuration Changes", show_lines=True)
+    table.add_column("Op", style="bold", width=3)
+    table.add_column("Type", style="cyan")
+    table.add_column("Component", style="bold")
+    table.add_column("Attribute", style="magenta")
+    table.add_column("Before", style="red", max_width=30)
+    table.add_column("After", style="green", max_width=30)
+    
+    for change in diff.added:
+        table.add_row(
+            "[green]+[/green]",
+            change.component_type_name_name,
+            change.component_name,
+            "[dim]--[/dim]",
+            "",
+            "[dim]new component[/dim]"
+        )
+    
+    for change in diff.removed:
+        table.add_row(
+            "[red]-[/red]",
+            change.component_type_name_name,
+            change.component_name,
+            "[dim]--[/dim]",
+            "[dim]component deleted[/dim]",
+            ""
+        )
+    
+    for change in diff.changed:
+        if change.changed_attributes:
+            for i, attr in enumerate(change.changed_attributes):
+                table.add_row(
+                    "[yellow]~[/yellow]" if i == 0 else "",
+                    change.component_type_name_name if i == 0 else "",
+                    change.component_name if i == 0 else "",
+                    attr.attribute_name,
+                    _format_value(attr.before, max_length=30),
+                    _format_value(attr.after, max_length=30)
+                )
+        else:
+            table.add_row(
+                "[yellow]~[/yellow]",
+                change.component_type_name_name,
+                change.component_name,
+                "[dim]--[/dim]",
+                "[dim]changed[/dim]",
+                "[dim]changed[/dim]"
+            )
+    
+    console.print(table)
+
+
+def _format_value(value, max_length: int = 100) -> str:
+    """Format a value for display, truncating if necessary."""
+    
+    if value is None:
+        return "null"
+    
+    # Check if this is an AttributeValue (Pydantic model or dict with 'value' key)
+    if isinstance(value, BaseModel) and hasattr(value, 'value'):
+        value = value.value
+        if value is None:
+            return "null"
+    elif isinstance(value, dict) and 'value' in value:
+        value = value['value']
+        if value is None:
+            return "null"
+    
+    if isinstance(value, BaseModel):
+        value_str = json.dumps(value.model_dump(), separators=(',', ':'))
+    elif isinstance(value, (dict, list)):
+        # Convert any nested BaseModel instances before serializing
+        def _to_serializable(obj):
+            if isinstance(obj, BaseModel):
+                return obj.model_dump()
+            if isinstance(obj, dict):
+                return {k: _to_serializable(v) for k, v in obj.items()}
+            if isinstance(obj, list):
+                return [_to_serializable(i) for i in obj]
+            return obj
+        value_str = json.dumps(_to_serializable(value), separators=(',', ':'))
+    else:
+        value_str = str(value)
+    
+    # Truncate if too long
+    if len(value_str) > max_length:
+        return value_str[:max_length-3] + "..."
+    
+    return value_str

{acex_cli-4.1.2 → acex_cli-4.2.0}/src/acex_cli/main.py

@@ -10,8 +10,10 @@ app = typer.Typer(
     name="acex",
     help="ACE-X - Automation & Control Ecosystem CLI",
     add_completion=True,
+    pretty_exceptions_enable=False
 )
 
+
 # Dynamiskt importera och lägg till alla Typer-appar från commands-mappen
 commands_path = pathlib.Path(__file__).parent / "commands"
 for module_info in pkgutil.iter_modules([str(commands_path)]):

{acex_cli-4.1.2 → acex_cli-4.2.0}/src/acex_cli/print_utils.py

@@ -2,6 +2,8 @@ from rich.table import Table
 from rich.console import Console
 from rich.tree import Tree
 from rich.text import Text
+from rich.panel import Panel
+from rich.syntax import Syntax
 
 console = Console()
 
@@ -45,3 +47,16 @@ def print_list_table(data, columns=None, title=None, pydantic_class=None):
         table.add_row(*(str(row.get(col, "")) for col in columns))
     console.print(table)
 
+
+def print_commands_box(commands: str, node_id: str):
+    """Print CLI commands in a styled panel box."""
+    syntax = Syntax(commands, "bash", theme="monokai", line_numbers=True, word_wrap=True)
+    console.print(
+        Panel(
+            syntax,
+            title=f"[bold cyan]node_id: {node_id}[/bold cyan]",
+            subtitle="[dim]commands to apply[/dim]",
+            border_style="cyan",
+            padding=(1, 2),
+        )
+    )

acex_cli-4.1.2/src/acex_cli/diff_formatters.py

@@ -1,261 +0,0 @@
-"""Formatters for displaying configuration diffs in CLI."""
-
-from rich.tree import Tree
-from rich.text import Text
-from rich.table import Table
-from rich.console import Console
-
-console = Console()
-
-
-def print_diff_summary(diff):
-    """Print a summary of the diff statistics."""
-    from acex_devkit.configdiffer.configdiffer import Diff
-    
-    if not isinstance(diff, Diff):
-        console.print("[red]Invalid diff object[/red]")
-        return
-    
-    if diff.is_empty():
-        console.print("[green]✓ No changes detected[/green]")
-        return
-    
-    summary = diff.summary()
-    
-    table = Table(title="Configuration Diff Summary")
-    table.add_column("Operation", style="bold")
-    table.add_column("Count", style="cyan", justify="right")
-    
-    if summary.get("add", 0) > 0:
-        table.add_row("Added", f"[green]{summary['add']}[/green]")
-    if summary.get("remove", 0) > 0:
-        table.add_row("Removed", f"[red]{summary['remove']}[/red]")
-    if summary.get("change", 0) > 0:
-        table.add_row("Changed", f"[yellow]{summary['change']}[/yellow]")
-    
-    console.print(table)
-
-
-def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
-    """
-    Print diff as a hierarchical tree view.
-    
-    Args:
-        diff: Diff object from configdiffer
-        max_depth: Maximum depth to show (None for unlimited)
-        show_values: Whether to show before/after values
-    """
-    from acex_devkit.configdiffer.configdiffer import Diff, DiffNode, DiffOp
-    
-    if not isinstance(diff, Diff):
-        console.print("[red]Invalid diff object[/red]")
-        return
-    
-    if diff.is_empty():
-        console.print("[green]✓ No changes detected[/green]")
-        return
-    
-    # Create colored title with summary
-    summary = diff.summary()
-    title = Text("🔀 Configuration Changes ", style="bold")
-    title.append("(", style="dim")
-    
-    parts = []
-    if summary.get("add", 0) > 0:
-        parts.append((f"+{summary['add']}", "green"))
-    if summary.get("remove", 0) > 0:
-        parts.append((f"-{summary['remove']}", "red"))
-    if summary.get("change", 0) > 0:
-        parts.append((f"~{summary['change']}", "yellow"))
-    
-    for i, (text, color) in enumerate(parts):
-        if i > 0:
-            title.append(" ", style="dim")
-        title.append(text, style=f"bold {color}")
-    
-    title.append(")", style="dim")
-    
-    tree = Tree(title)
-    
-    def add_node(parent_tree, node: DiffNode, key: str, depth: int = 0):
-        """Recursively add nodes to the tree."""
-        if max_depth is not None and depth > max_depth:
-            return
-        
-        # Format the node based on operation
-        if node.op == DiffOp.ADD:
-            style = "green"
-            prefix = "+ "
-            value_str = f" = {_format_value(node.after)}" if show_values and node.after is not None else ""
-        elif node.op == DiffOp.REMOVE:
-            style = "red"
-            prefix = "- "
-            value_str = f" = {_format_value(node.before)}" if show_values and node.before is not None else ""
-        elif node.op == DiffOp.CHANGE:
-            style = "yellow"
-            prefix = "~ "
-            if show_values and node.children is None:
-                # Leaf node with changed value
-                value_str = f" {_format_value(node.before)} → {_format_value(node.after)}"
-            else:
-                value_str = ""
-        else:
-            style = "white"
-            prefix = "  "
-            value_str = ""
-        
-        # Create the tree node
-        label = Text()
-        label.append(prefix, style=f"bold {style}")
-        label.append(key, style=style)
-        label.append(value_str, style=style)
-        
-        branch = parent_tree.add(label)
-        
-        # Add children if they exist
-        if node.children:
-            for child_key, child_node in sorted(node.children.items()):
-                add_node(branch, child_node, child_key, depth + 1)
-    
-    # Start with root's children
-    if diff.root.children:
-        for key, node in sorted(diff.root.children.items()):
-            add_node(tree, node, key, depth=0)
-    
-    console.print(tree)
-
-
-def print_diff_compact(diff, show_unchanged: bool = False):
-    """
-    Print diff in a compact, git-like format.
-    
-    Args:
-        diff: Diff object from configdiffer
-        show_unchanged: Whether to show unchanged paths
-    """
-    from acex_devkit.configdiffer.configdiffer import Diff, DiffNode, DiffOp
-    
-    if not isinstance(diff, Diff):
-        console.print("[red]Invalid diff object[/red]")
-        return
-    
-    if diff.is_empty():
-        console.print("[green]✓ No changes detected[/green]")
-        return
-    
-    changes = []
-    
-    def collect_changes(node: DiffNode, path: str = ""):
-        """Recursively collect all changes with their paths."""
-        if node.children:
-            for key, child in sorted(node.children.items()):
-                new_path = f"{path}.{key}" if path else key
-                collect_changes(child, new_path)
-        else:
-            # Leaf node
-            changes.append((path, node))
-    
-    collect_changes(diff.root)
-    
-    # Group by operation type
-    adds = [(p, n) for p, n in changes if n.op == DiffOp.ADD]
-    removes = [(p, n) for p, n in changes if n.op == DiffOp.REMOVE]
-    modifications = [(p, n) for p, n in changes if n.op == DiffOp.CHANGE]
-    
-    if adds:
-        console.print("\n[bold green]✚ Added:[/bold green]")
-        for path, node in adds:
-            value_str = _format_value(node.after, max_length=60)
-            console.print(f"  [green]+ {path}[/green] = {value_str}")
-    
-    if removes:
-        console.print("\n[bold red]✖ Removed:[/bold red]")
-        for path, node in removes:
-            value_str = _format_value(node.before, max_length=60)
-            console.print(f"  [red]- {path}[/red] = {value_str}")
-    
-    if modifications:
-        console.print("\n[bold yellow]⚡ Modified:[/bold yellow]")
-        for path, node in modifications:
-            before_str = _format_value(node.before, max_length=40)
-            after_str = _format_value(node.after, max_length=40)
-            console.print(f"  [yellow]~ {path}[/yellow]")
-            console.print(f"    [red]- {before_str}[/red]")
-            console.print(f"    [green]+ {after_str}[/green]")
-
-
-def print_diff_flat(diff):
-    """
-    Print diff in a flat list format, good for quick scanning.
-    
-    Args:
-        diff: Diff object from configdiffer
-    """
-    from acex_devkit.configdiffer.configdiffer import Diff, DiffNode, DiffOp
-    
-    if not isinstance(diff, Diff):
-        console.print("[red]Invalid diff object[/red]")
-        return
-    
-    if diff.is_empty():
-        console.print("[green]✓ No changes detected[/green]")
-        return
-    
-    changes = []
-    
-    def collect_changes(node: DiffNode, path: str = ""):
-        """Recursively collect all changes with their paths."""
-        if node.children:
-            for key, child in sorted(node.children.items()):
-                new_path = f"{path}.{key}" if path else key
-                collect_changes(child, new_path)
-        else:
-            # Leaf node
-            changes.append((path, node))
-    
-    collect_changes(diff.root)
-    
-    # Create table
-    table = Table(title="Configuration Changes", show_lines=True)
-    table.add_column("Op", style="bold", width=3)
-    table.add_column("Path", style="cyan")
-    table.add_column("Before", style="red", max_width=40)
-    table.add_column("After", style="green", max_width=40)
-    
-    for path, node in changes:
-        if node.op == DiffOp.ADD:
-            op_symbol = "[green]+[/green]"
-            before = ""
-            after = _format_value(node.after, max_length=40)
-        elif node.op == DiffOp.REMOVE:
-            op_symbol = "[red]-[/red]"
-            before = _format_value(node.before, max_length=40)
-            after = ""
-        else:  # CHANGE
-            op_symbol = "[yellow]~[/yellow]"
-            before = _format_value(node.before, max_length=40)
-            after = _format_value(node.after, max_length=40)
-        
-        table.add_row(op_symbol, path, before, after)
-    
-    console.print(table)
-
-
-def _format_value(value, max_length: int = 100) -> str:
-    """Format a value for display, truncating if necessary."""
-    import json
-    
-    if value is None:
-        return "[dim]null[/dim]"
-    
-    if isinstance(value, (dict, list)):
-        # For complex objects, show compact JSON
-        value_str = json.dumps(value, separators=(',', ':'))
-    else:
-        value_str = str(value)
-    
-    # Truncate if too long
-    if len(value_str) > max_length:
-        return value_str[:max_length-3] + "..."
-    
-    return value_str