griptape-nodes 0.64.11__py3-none-any.whl → 0.65.1__py3-none-any.whl

griptape_nodes/app/app.py

@@ -73,6 +73,8 @@ websocket_event_loop_ready = threading.Event()
 # Semaphore to limit concurrent requests
 REQUEST_SEMAPHORE = asyncio.Semaphore(100)
 
+config_manager = GriptapeNodes.ConfigManager()
+
 
 class EventLogHandler(logging.Handler):
     """Custom logging handler that emits log messages as AppEvents.
@@ -81,18 +83,24 @@ class EventLogHandler(logging.Handler):
     """
 
     def emit(self, record: logging.LogRecord) -> None:
-        log_event = AppEvent(
-            payload=LogHandlerEvent(message=record.getMessage(), levelname=record.levelname, created=record.created)
-        )
-        griptape_nodes.EventManager().put_event(log_event)
+        log_level_no = logging.getLevelNamesMapping()[config_manager.get_config_value("log_level").upper()]
+        if record.levelno >= log_level_no:
+            log_event = AppEvent(
+                payload=LogHandlerEvent(message=record.getMessage(), levelname=record.levelname, created=record.created)
+            )
+            griptape_nodes.EventManager().put_event(log_event)
 
 
 # Logger for this module. Important that this is not the same as the griptape_nodes logger or else we'll have infinite log events.
 logger = logging.getLogger("griptape_nodes_app")
 
+# Get configured log level from config
+log_level_str = config_manager.get_config_value("log_level").upper()
+log_level = logging.getLevelNamesMapping()[log_level_str]
+
 griptape_nodes_logger = logging.getLogger("griptape_nodes")
 griptape_nodes_logger.addHandler(EventLogHandler())
-griptape_nodes_logger.setLevel(logging.INFO)
+griptape_nodes_logger.setLevel(log_level)
 
 # Root logger only gets RichHandler for console output
 logging.basicConfig(
@@ -313,6 +321,10 @@ async def _process_app_event(event: AppEvent) -> None:
 
 async def _process_node_event(event: GriptapeNodeEvent) -> None:
     """Process GriptapeNodeEvents and send them to the API (async version)."""
+    # Check if events are suppressed
+    if griptape_nodes.EventManager().should_suppress_event(event):
+        return
+
     # Emit the result back to the GUI
     result_event = event.wrapped_event
 
@@ -341,11 +353,19 @@ async def _process_node_event(event: GriptapeNodeEvent) -> None:
 
 async def _process_execution_node_event(event: ExecutionGriptapeNodeEvent) -> None:
     """Process ExecutionGriptapeNodeEvents and send them to the API (async version)."""
+    # Check if events are suppressed
+    if griptape_nodes.EventManager().should_suppress_event(event):
+        return
+
     await _send_message("execution_event", event.wrapped_event.json())
 
 
 async def _process_progress_event(gt_event: ProgressEvent) -> None:
     """Process Griptape framework events and send them to the API (async version)."""
+    # Check if events are suppressed
+    if griptape_nodes.EventManager().should_suppress_event(gt_event):
+        return
+
     node_name = gt_event.node_name
     if node_name:
         value = gt_event.value

griptape_nodes/cli/commands/init.py

@@ -1,9 +1,8 @@
 """Init command for Griptape Nodes CLI."""
 
-import asyncio
 import json
 from pathlib import Path
-from typing import Annotated, Any
+from typing import Annotated, Any, NamedTuple
 
 import typer
 from rich.box import HEAVY_EDGE
@@ -11,12 +10,10 @@ from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
 from rich.table import Table
 
-from griptape_nodes.cli.commands.libraries import _sync_libraries
 from griptape_nodes.cli.shared import (
     CONFIG_DIR,
     CONFIG_FILE,
     ENV_FILE,
-    ENV_LIBRARIES_BASE_DIR,
     GT_CLOUD_BASE_URL,
     NODES_APP_URL,
     InitConfig,
@@ -25,6 +22,9 @@ from griptape_nodes.cli.shared import (
 from griptape_nodes.drivers.storage import StorageBackend
 from griptape_nodes.drivers.storage.griptape_cloud_storage_driver import GriptapeCloudStorageDriver
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.retained_mode.managers.settings import LIBRARIES_TO_DOWNLOAD_KEY, LIBRARIES_TO_REGISTER_KEY
+from griptape_nodes.utils.git_utils import extract_repo_name_from_url
+from griptape_nodes.utils.library_utils import filter_old_xdg_library_paths
 
 config_manager = GriptapeNodes.ConfigManager()
 secrets_manager = GriptapeNodes.SecretsManager()
@@ -54,10 +54,6 @@ def init_command(  # noqa: PLR0913
             help="Install the Griptape Cloud Library.",
         ),
     ] = None,
-    libraries_sync: Annotated[
-        bool | None,
-        typer.Option("--libraries-sync/--no-libraries-sync", help="Sync the Griptape Nodes libraries."),
-    ] = None,
     no_interactive: Annotated[  # noqa: FBT002
         bool,
         typer.Option(help="Run init in non-interactive mode (no prompts)."),
@@ -93,7 +89,6 @@ def init_command(  # noqa: PLR0913
             register_griptape_cloud_library=register_griptape_cloud_library,
             config_values=config_values,
             secret_values=secret_values,
-            libraries_sync=libraries_sync,
             bucket_name=bucket_name,
             hf_token=hf_token,
         )
@@ -111,10 +106,6 @@ def _run_init(config: InitConfig) -> None:
     # Run configuration flow
     _run_init_configuration(config)
 
-    # Sync libraries
-    if config.libraries_sync is not False:
-        asyncio.run(_sync_libraries(load_libraries_from_config=False))
-
     console.print("[bold green]Initialization complete![/bold green]")
 
 
@@ -240,14 +231,24 @@ def _handle_additional_library_config(config: InitConfig) -> bool | None:
         )
 
     if register_advanced_library is not None or register_griptape_cloud_library is not None:
-        libraries_to_register = _build_libraries_list(
+        libraries_config = _build_libraries_list(
             register_advanced_library=register_advanced_library,
             register_griptape_cloud_library=register_griptape_cloud_library,
         )
         config_manager.set_config_value(
-            "app_events.on_app_initialization_complete.libraries_to_register", libraries_to_register
+            LIBRARIES_TO_DOWNLOAD_KEY,
+            libraries_config.libraries_to_download,
+        )
+        config_manager.set_config_value(
+            LIBRARIES_TO_REGISTER_KEY,
+            libraries_config.libraries_to_register,
+        )
+        console.print(
+            f"[bold green]Libraries to download: {', '.join(libraries_config.libraries_to_download)}[/bold green]"
+        )
+        console.print(
+            f"[bold green]Libraries to register: {', '.join(libraries_config.libraries_to_register)}[/bold green]"
         )
-        console.print(f"[bold green]Libraries to register set to: {', '.join(libraries_to_register)}[/bold green]")
 
     return register_advanced_library
 
@@ -500,62 +501,72 @@ def _prompt_for_griptape_cloud_library(*, default_prompt_for_griptape_cloud_libr
     return Confirm.ask("Register Griptape Cloud Library?", default=default_prompt_for_griptape_cloud_library)
 
 
+class LibrariesConfig(NamedTuple):
+    """Configuration for library lists."""
+
+    libraries_to_download: list[str]
+    libraries_to_register: list[str]
+
+
 def _build_libraries_list(
     *, register_advanced_library: bool | None = False, register_griptape_cloud_library: bool | None = False
-) -> list[str]:
-    """Builds the list of libraries to register based on library settings."""
-    # TODO: https://github.com/griptape-ai/griptape-nodes/issues/929
-    libraries_key = "app_events.on_app_initialization_complete.libraries_to_register"
-    library_base_dir = Path(ENV_LIBRARIES_BASE_DIR)
-
-    current_libraries = config_manager.get_config_value(
-        libraries_key,
+) -> LibrariesConfig:
+    """Builds the lists of libraries to download and register based on library settings."""
+    # Get current configuration for both lists
+    download_key = LIBRARIES_TO_DOWNLOAD_KEY
+    register_key = LIBRARIES_TO_REGISTER_KEY
+
+    current_downloads = config_manager.get_config_value(
+        download_key,
         config_source="user_config",
-        default=config_manager.get_config_value(libraries_key, config_source="default_config", default=[]),
+        default=config_manager.get_config_value(download_key, config_source="default_config", default=[]),
     )
-    new_libraries = current_libraries.copy()
+    current_register = config_manager.get_config_value(
+        register_key,
+        config_source="user_config",
+        default=config_manager.get_config_value(register_key, config_source="default_config", default=[]),
+    )
+
+    new_downloads = current_downloads.copy()
+    new_register = current_register.copy()
 
-    def _get_library_identifier(library_path: str) -> str:
-        """Get the unique identifier for a library based on parent/filename."""
-        path = Path(library_path)
-        return f"{path.parent.name}/{path.name}"
+    # Remove old XDG data home library paths from libraries_to_register
+    new_register, _ = filter_old_xdg_library_paths(new_register)
 
-    # Create a set of current library identifiers for fast lookup
-    current_identifiers = {_get_library_identifier(lib) for lib in current_libraries}
+    # Create a set of current download identifiers for fast lookup
+    current_download_identifiers = {extract_repo_name_from_url(lib) for lib in current_downloads}
 
-    default_library = str(library_base_dir / "griptape_nodes_library/griptape_nodes_library.json")
-    default_identifier = _get_library_identifier(default_library)
-    # If somehow the user removed the default library, add it back
-    if default_identifier not in current_identifiers:
-        new_libraries.append(default_library)
+    # Default library
+    default_library = "https://github.com/griptape-ai/griptape-nodes-library-standard@stable"
+    default_identifier = extract_repo_name_from_url(default_library)
+    if default_identifier not in current_download_identifiers:
+        new_downloads.append(default_library)
 
-    advanced_media_library = str(library_base_dir / "griptape_nodes_advanced_media_library/griptape_nodes_library.json")
-    advanced_identifier = _get_library_identifier(advanced_media_library)
+    # Advanced media library
+    advanced_media_library = "https://github.com/griptape-ai/griptape-nodes-library-advanced-media@stable"
+    advanced_identifier = extract_repo_name_from_url(advanced_media_library)
     if register_advanced_library:
-        # If the advanced media library is not registered, add it
-        if advanced_identifier not in current_identifiers:
-            new_libraries.append(advanced_media_library)
+        if advanced_identifier not in current_download_identifiers:
+            new_downloads.append(advanced_media_library)
     else:
-        # If the advanced media library is registered, remove it
-        libraries_to_remove = [lib for lib in new_libraries if _get_library_identifier(lib) == advanced_identifier]
+        libraries_to_remove = [lib for lib in new_downloads if extract_repo_name_from_url(lib) == advanced_identifier]
         for lib in libraries_to_remove:
-            new_libraries.remove(lib)
+            new_downloads.remove(lib)
 
-    griptape_cloud_library = str(library_base_dir / "griptape_cloud/griptape_nodes_library.json")
-    griptape_cloud_identifier = _get_library_identifier(griptape_cloud_library)
+    # Griptape Cloud library
+    griptape_cloud_library = "https://github.com/griptape-ai/griptape-nodes-library-griptape-cloud@stable"
+    griptape_cloud_identifier = extract_repo_name_from_url(griptape_cloud_library)
     if register_griptape_cloud_library:
-        # If the griptape cloud library is not registered, add it
-        if griptape_cloud_identifier not in current_identifiers:
-            new_libraries.append(griptape_cloud_library)
+        if griptape_cloud_identifier not in current_download_identifiers:
+            new_downloads.append(griptape_cloud_library)
     else:
-        # If the griptape cloud library is registered, remove it
         libraries_to_remove = [
-            lib for lib in new_libraries if _get_library_identifier(lib) == griptape_cloud_identifier
+            lib for lib in new_downloads if extract_repo_name_from_url(lib) == griptape_cloud_identifier
         ]
         for lib in libraries_to_remove:
-            new_libraries.remove(lib)
+            new_downloads.remove(lib)
 
-    return new_libraries
+    return LibrariesConfig(libraries_to_download=new_downloads, libraries_to_register=new_register)
 
 
 def _create_new_bucket(bucket_name: str) -> str:

griptape_nodes/cli/commands/libraries.py

@@ -1,101 +1,108 @@
 """Libraries command for Griptape Nodes CLI."""
 
 import asyncio
-import shutil
-import tarfile
-import tempfile
-from pathlib import Path
 
-import httpx
 import typer
-from rich.progress import Progress
 
-from griptape_nodes.cli.shared import (
-    ENV_LIBRARIES_BASE_DIR,
-    LATEST_TAG,
-    NODES_TARBALL_URL,
-    console,
+from griptape_nodes.cli.shared import console
+from griptape_nodes.retained_mode.events.library_events import (
+    DownloadLibraryRequest,
+    DownloadLibraryResultSuccess,
+    SyncLibrariesRequest,
+    SyncLibrariesResultSuccess,
 )
-from griptape_nodes.retained_mode.events.os_events import DeleteFileRequest, DeleteFileResultSuccess
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-from griptape_nodes.utils.version_utils import get_current_version, get_install_source
+from griptape_nodes.utils.git_utils import normalize_github_url
 
 app = typer.Typer(help="Manage local libraries.")
 
 
 @app.command()
-def sync() -> None:
-    """Sync libraries with your current engine version."""
-    asyncio.run(_sync_libraries())
-
+def sync(
+    overwrite: bool = typer.Option(False, "--overwrite", help="Discard uncommitted changes in libraries"),  # noqa: FBT001
+) -> None:
+    """Sync all libraries to latest versions from their git repositories."""
+    asyncio.run(_sync_libraries(overwrite_existing=overwrite))
+
+
+async def _sync_libraries(*, overwrite_existing: bool) -> None:
+    """Sync all libraries by checking for updates and installing dependencies."""
+    console.print("[bold cyan]Syncing libraries...[/bold cyan]")
+
+    # Create sync request with provided parameters
+    request = SyncLibrariesRequest(
+        overwrite_existing=overwrite_existing,
+    )
+
+    # Execute the sync
+    result = await GriptapeNodes.ahandle_request(request)
+
+    # Display results - failure case first
+    if not isinstance(result, SyncLibrariesResultSuccess):
+        console.print(f"[red]Failed to sync libraries: {result.result_details}[/red]")
+        return
+
+    # Success path
+    console.print(f"[green]Checked {result.libraries_checked} libraries[/green]")
+
+    if result.libraries_updated > 0:
+        console.print(f"[bold green]Updated {result.libraries_updated} libraries:[/bold green]")
+        for lib_name, update_info in result.update_summary.items():
+            if update_info.get("status") == "updated":
+                console.print(
+                    f"  [green]✓ {lib_name}: {update_info['old_version']} → {update_info['new_version']}[/green]"
+                )
+            elif update_info.get("status") == "failed":
+                console.print(f"  [red]✗ {lib_name}: {update_info.get('error', 'Unknown error')}[/red]")
+    else:
+        console.print("[green]All libraries are up to date[/green]")
 
-async def _sync_libraries(*, load_libraries_from_config: bool = True) -> None:
-    """Download and sync Griptape Nodes libraries, copying only directories from synced libraries.
+    console.print("[bold green]Libraries synced successfully.[/bold green]")
 
-    Args:
-        load_libraries_from_config (bool): If True, re-initialize all libraries from config
 
-    """
-    install_source, _ = get_install_source()
-    # Unless we're installed from PyPi, grab libraries from the 'latest' tag
-    if install_source == "pypi":
-        version = get_current_version()
-    else:
-        version = LATEST_TAG
-
-    console.print(f"[bold cyan]Fetching Griptape Nodes libraries ({version})...[/bold cyan]")
-
-    tar_url = NODES_TARBALL_URL.format(tag=version)
-    console.print(f"[green]Downloading from {tar_url}[/green]")
-    dest_nodes = Path(ENV_LIBRARIES_BASE_DIR)
-
-    with tempfile.TemporaryDirectory() as tmp:
-        tar_path = Path(tmp) / "nodes.tar.gz"
-
-        # Streaming download with a tiny progress bar
-        with httpx.stream("GET", tar_url, follow_redirects=True) as r, Progress() as progress:
-            task = progress.add_task("[green]Downloading...", total=int(r.headers.get("Content-Length", 0)))
-            progress.start()
-            try:
-                r.raise_for_status()
-            except httpx.HTTPStatusError as e:
-                console.print(f"[red]Error fetching libraries: {e}[/red]")
-                return
-            with tar_path.open("wb") as f:
-                for chunk in r.iter_bytes():
-                    f.write(chunk)
-                    progress.update(task, advance=len(chunk))
-
-        console.print("[green]Extracting...[/green]")
-        # Extract and locate extracted directory
-        with tarfile.open(tar_path) as tar:
-            tar.extractall(tmp, filter="data")
-
-        extracted_root = next(Path(tmp).glob("griptape-nodes-*"))
-        extracted_libs = extracted_root / "libraries"
-
-        # Copy directories from synced libraries without removing existing content
-        console.print(f"[green]Syncing libraries to {dest_nodes.resolve()}...[/green]")
-        dest_nodes.mkdir(parents=True, exist_ok=True)
-        for library_dir in extracted_libs.iterdir():
-            if library_dir.is_dir():
-                dest_library_dir = dest_nodes / library_dir.name
-                if dest_library_dir.exists():
-                    # Use DeleteFileRequest for centralized deletion with Windows compatibility
-                    request = DeleteFileRequest(path=str(dest_library_dir), workspace_only=False)
-                    result = await GriptapeNodes.OSManager().on_delete_file_request(request)
-                    if not isinstance(result, DeleteFileResultSuccess):
-                        console.print(f"[yellow]Warning: Failed to delete existing library {library_dir.name}[/yellow]")
-                shutil.copytree(library_dir, dest_library_dir)
-                console.print(f"[green]Synced library: {library_dir.name}[/green]")
-
-    # Re-initialize all libraries from config
-    if load_libraries_from_config:
-        console.print("[bold cyan]Initializing libraries...[/bold cyan]")
-        try:
-            await GriptapeNodes.LibraryManager().load_all_libraries_from_config()
-            console.print("[bold green]Libraries Initialized successfully.[/bold green]")
-        except Exception as e:
-            console.print(f"[red]Error initializing libraries: {e}[/red]")
-
-    console.print("[bold green]Libraries synced.[/bold green]")
+@app.command()
+def download(
+    git_url: str = typer.Argument(..., help="Git repository URL to download"),
+    branch: str | None = typer.Option(None, "--branch", help="Branch, tag, or commit to checkout"),
+    target_dir: str | None = typer.Option(None, "--target-dir", help="Target directory name"),
+    download_dir: str | None = typer.Option(None, "--download-dir", help="Parent directory for library download"),
+    overwrite: bool = typer.Option(False, "--overwrite", help="Overwrite existing library directory if it exists"),  # noqa: FBT001
+) -> None:
+    """Download a library from a git repository."""
+    asyncio.run(_download_library(git_url, branch, target_dir, download_dir, overwrite_existing=overwrite))
+
+
+async def _download_library(
+    git_url: str,
+    branch_tag_commit: str | None,
+    target_directory_name: str | None,
+    download_directory: str | None,
+    *,
+    overwrite_existing: bool,
+) -> None:
+    """Download a library from a git repository."""
+    # Normalize GitHub shorthand to full URL
+    git_url = normalize_github_url(git_url)
+
+    console.print(f"[bold cyan]Downloading library from {git_url}...[/bold cyan]")
+
+    # Create the download request
+    request = DownloadLibraryRequest(
+        git_url=git_url,
+        branch_tag_commit=branch_tag_commit,
+        target_directory_name=target_directory_name,
+        download_directory=download_directory,
+        overwrite_existing=overwrite_existing,
+    )
+
+    # Execute the download
+    result = await GriptapeNodes.ahandle_request(request)
+
+    # Display results - failure case first
+    if not isinstance(result, DownloadLibraryResultSuccess):
+        console.print(f"[red]Failed to download library: {result.result_details}[/red]")
+        return
+
+    # Success path
+    console.print(f"[bold green]Library '{result.library_name}' downloaded successfully![/bold green]")
+    console.print(f"[green]Downloaded to: {result.library_path}[/green]")

griptape_nodes/cli/commands/self.py

@@ -1,23 +1,31 @@
 """Self command for Griptape Nodes CLI."""
 
+import asyncio
+import json
+import platform
 import shutil
 import sys
 
 import typer
+from rich.table import Table
 
 from griptape_nodes.cli.shared import (
     CONFIG_DIR,
+    CONFIG_FILE,
     DATA_DIR,
     GITHUB_UPDATE_URL,
     LATEST_TAG,
     PYPI_UPDATE_URL,
     console,
 )
+from griptape_nodes.node_library.library_registry import LibraryRegistry
+from griptape_nodes.retained_mode.events.library_events import LoadLibrariesRequest
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 from griptape_nodes.utils.uv_utils import find_uv_bin
 from griptape_nodes.utils.version_utils import (
     get_complete_version_string,
     get_current_version,
+    get_install_source,
     get_latest_version_git,
     get_latest_version_pypi,
 )
@@ -47,6 +55,12 @@ def version() -> None:
     _print_current_version()
 
 
+@app.command()
+def info() -> None:
+    """Display system information for debugging."""
+    asyncio.run(_print_system_info_async())
+
+
 def _get_latest_version(package: str, install_source: str) -> str:
     """Fetches the latest release tag from PyPI.
 
@@ -118,3 +132,110 @@ def _uninstall_self() -> None:
     # Remove the tool using UV
     uv_path = find_uv_bin()
     os_manager.replace_process([uv_path, "tool", "uninstall", "griptape-nodes"])
+
+
+async def _print_system_info_async() -> None:
+    """Print comprehensive system information (async wrapper to load libraries)."""
+    # Load libraries from configuration first
+    load_request = LoadLibrariesRequest()
+    await GriptapeNodes.ahandle_request(load_request)
+
+    # Now print all the info
+    _print_system_info()
+
+
+def _print_system_info() -> None:
+    """Print comprehensive system information."""
+    console.print("\n[bold cyan]Griptape Nodes System Information[/bold cyan]\n")
+
+    _print_engine_info()
+    _print_platform_info()
+    _print_paths_info()
+    _print_configuration()
+    _print_registered_libraries()
+
+
+def _print_engine_info() -> None:
+    """Print engine version information."""
+    version_string = get_complete_version_string()
+    install_source, commit_id = get_install_source()
+
+    console.print("[bold]Engine:[/bold]")
+    console.print(f"  Version: {version_string}")
+    console.print(f"  Install Source: {install_source}")
+    if commit_id:
+        console.print(f"  Commit ID: {commit_id}")
+    console.print()
+
+
+def _print_platform_info() -> None:
+    """Print platform information."""
+    console.print("[bold]Platform:[/bold]")
+    console.print(f"  OS: {platform.system()}")
+    console.print(f"  OS Version: {platform.version()}")
+    console.print(f"  OS Release: {platform.release()}")
+    console.print(f"  Architecture: {platform.machine()}")
+    console.print(f"  Python Version: {platform.python_version()}")
+    console.print(f"  Python Implementation: {platform.python_implementation()}")
+    console.print(f"  Python Executable: {sys.executable}")
+    console.print()
+
+
+def _print_paths_info() -> None:
+    """Print configuration paths."""
+    console.print("[bold]Paths:[/bold]")
+    console.print(f"  Config Directory: {CONFIG_DIR}")
+    console.print(f"  Config File: {CONFIG_FILE}")
+    console.print(f"  Data Directory: {DATA_DIR}")
+
+    workspace_dir = config_manager.get_config_value("file_system.directories.workspace_directory")
+    if workspace_dir:
+        console.print(f"  Workspace Directory: {workspace_dir}")
+    console.print()
+
+
+def _print_configuration() -> None:
+    """Print full configuration."""
+    console.print("[bold]Configuration:[/bold]")
+    try:
+        full_config = config_manager.merged_config
+        config_json = json.dumps(full_config, indent=2, default=str)
+        console.print(f"[dim]{config_json}[/dim]")
+    except Exception as e:
+        console.print(f"  [red]Error retrieving configuration: {e}[/red]")
+    console.print()
+
+
+def _print_registered_libraries() -> None:
+    """Print registered libraries information."""
+    console.print("[bold]Registered Libraries:[/bold]")
+    try:
+        library_names = LibraryRegistry.list_libraries()
+        if not library_names:
+            console.print("  [yellow]No libraries registered[/yellow]")
+            console.print()
+            return
+
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Library Name", style="cyan")
+        table.add_column("Version", style="green")
+        table.add_column("Engine Version", style="yellow")
+        table.add_column("Author", style="blue")
+
+        for library_name in library_names:
+            try:
+                library = LibraryRegistry.get_library(library_name)
+                metadata = library.get_metadata()
+                table.add_row(
+                    library_name,
+                    metadata.library_version,
+                    metadata.engine_version,
+                    metadata.author,
+                )
+            except KeyError:
+                table.add_row(library_name, "[red]Error[/red]", "[red]Error[/red]", "[red]Error[/red]")
+
+        console.print(table)
+    except Exception as e:
+        console.print(f"  [red]Error retrieving libraries: {e}[/red]")
+    console.print()