glaip-sdk 0.0.4__py3-none-any.whl → 0.0.5b1__py3-none-any.whl

glaip_sdk/cli/commands/tools.py

@@ -6,20 +6,40 @@ Authors:
 
 import json
 import re
+from pathlib import Path
 
 import click
 from rich.console import Console
-from rich.panel import Panel
 from rich.text import Text
 
-from ..utils import (
+from glaip_sdk.cli.display import (
+    display_api_error,
+    display_confirmation_prompt,
+    display_creation_success,
+    display_deletion_success,
+    display_update_success,
+    handle_json_output,
+    handle_rich_output,
+)
+from glaip_sdk.cli.io import (
+    export_resource_to_file_with_validation as export_resource_to_file,
+)
+from glaip_sdk.cli.io import (
+    fetch_raw_resource_details,
+)
+from glaip_sdk.cli.io import (
+    load_resource_from_file_with_validation as load_resource_from_file,
+)
+from glaip_sdk.cli.resolution import resolve_resource_reference
+from glaip_sdk.cli.utils import (
     coerce_to_row,
     get_client,
     output_flags,
     output_list,
     output_result,
-    resolve_resource,
 )
+from glaip_sdk.utils import format_datetime
+from glaip_sdk.utils.import_export import merge_import_with_cli_args
 
 console = Console()
 
@@ -32,12 +52,14 @@ def tools_group():
 
 def _resolve_tool(ctx, client, ref, select=None):
     """Resolve tool reference (ID or name) with ambiguity handling."""
-    return resolve_resource(
+    return resolve_resource_reference(
         ctx,
+        client,
         ref,
-        get_by_id=client.get_tool,
-        find_by_name=client.find_tools,
-        label="Tool",
+        "tool",
+        client.get_tool,
+        client.find_tools,
+        "Tool",
         select=select,
     )
 
@@ -91,12 +113,19 @@ def _parse_tags(tags: str | None) -> list[str]:
 
 @tools_group.command(name="list")
 @output_flags()
+@click.option(
+    "--type",
+    "tool_type",
+    help="Filter tools by type (e.g., custom, native)",
+    type=str,
+    required=False,
+)
 @click.pass_context
-def list_tools(ctx):
+def list_tools(ctx, tool_type):
     """List all tools."""
     try:
         client = get_client(ctx)
-        tools = client.list_tools()
+        tools = client.list_tools(tool_type=tool_type)
 
         # Define table columns: (data_key, header, style, width)
         columns = [
@@ -137,19 +166,59 @@ def list_tools(ctx):
     "--tags",
     help="Comma-separated tags for the tool",
 )
+@click.option(
+    "--import",
+    "import_file",
+    type=click.Path(exists=True, dir_okay=False),
+    help="Import tool configuration from JSON file",
+)
 @output_flags()
 @click.pass_context
-def create(ctx, file_arg, file, name, description, tags):
-    """Create a new tool."""
+def create(ctx, file_arg, file, name, description, tags, import_file):
+    """Create a new tool.
+
+    Examples:
+        aip tools create --name "My Tool" --description "A helpful tool"
+        aip tools create tool.py  # Create from file
+        aip tools create --import tool.json  # Create from exported configuration
+    """
     try:
         client = get_client(ctx)
 
+        # Initialize merged_data for cases without import_file
+        merged_data = {}
+
+        # Handle import from file
+        if import_file:
+            import_data = load_resource_from_file(Path(import_file), "tool")
+
+            # Merge CLI args with imported data
+            cli_args = {
+                "name": name,
+                "description": description,
+                "tags": tags,
+            }
+
+            merged_data = merge_import_with_cli_args(import_data, cli_args)
+        else:
+            # No import file - use CLI args directly
+            merged_data = {
+                "name": name,
+                "description": description,
+                "tags": tags,
+            }
+
+        # Extract merged values
+        name = merged_data.get("name")
+        description = merged_data.get("description")
+        tags = merged_data.get("tags")
+
         # Allow positional file argument for better DX (matches examples)
         if not file and file_arg:
             file = file_arg
 
         # Validate required parameters based on creation method
-        if not file:
+        if not file and not import_file:
             # Metadata-only tool creation
             if not name:
                 raise click.ClickException(
@@ -168,14 +237,14 @@ def create(ctx, file_arg, file, name, description, tags):
 
             # Upload the plugin code as-is (no rewrite)
             tool = client.create_tool_from_code(
-                tool_name,
-                code_content,
+                name=tool_name,
+                code=code_content,
                 framework="langchain",  # Always langchain
                 description=description,
-                tags=_parse_tags(tags),
+                tags=_parse_tags(tags) if tags else None,
             )
         else:
-            # Metadata-only tool creation
+            # Metadata-only tool creation or import from file
             tool_kwargs = {}
             if name:
                 tool_kwargs["name"] = name
@@ -186,60 +255,141 @@ def create(ctx, file_arg, file, name, description, tags):
             if tags:
                 tool_kwargs["tags"] = _parse_tags(tags)
 
+            # If importing from file, include all other detected attributes
+            if import_file:
+                # Add all other attributes from import data (excluding already handled ones)
+                excluded_fields = {
+                    "name",
+                    "description",
+                    "tags",
+                    # System-only fields that shouldn't be passed to create_tool
+                    "id",
+                    "created_at",
+                    "updated_at",
+                    "tool_type",
+                    "framework",
+                    "version",
+                }
+                for key, value in merged_data.items():
+                    if key not in excluded_fields and value is not None:
+                        tool_kwargs[key] = value
+
             tool = client.create_tool(**tool_kwargs)
 
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps(tool.model_dump(), indent=2))
-        else:
-            # Rich output
-            creation_method = (
-                "file upload (custom)" if file else "metadata only (native)"
-            )
-            panel = Panel(
-                f"[green]✅ Tool '{tool.name}' created successfully via {creation_method}![/green]\n\n"
-                f"ID: {tool.id}\n"
-                f"Framework: {getattr(tool, 'framework', 'N/A')} (default)\n"
-                f"Type: {getattr(tool, 'tool_type', 'N/A')} (auto-detected)\n"
-                f"Description: {getattr(tool, 'description', 'No description')}",
-                title="🔧 Tool Created",
-                border_style="green",
-            )
-            console.print(panel)
+        # Handle JSON output
+        handle_json_output(ctx, tool.model_dump())
+
+        # Handle Rich output
+        creation_method = "file upload (custom)" if file else "metadata only (native)"
+        rich_panel = display_creation_success(
+            "Tool",
+            tool.name,
+            tool.id,
+            Framework=getattr(tool, "framework", "N/A"),
+            Type=getattr(tool, "tool_type", "N/A"),
+            Description=getattr(tool, "description", "No description"),
+            Method=creation_method,
+        )
+        handle_rich_output(ctx, rich_panel)
 
     except Exception as e:
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(Text(f"[red]Error creating tool: {e}[/red]"))
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            display_api_error(e, "tool creation")
         raise click.ClickException(str(e))
 
 
 @tools_group.command()
 @click.argument("tool_ref")
 @click.option("--select", type=int, help="Choose among ambiguous matches (1-based)")
+@click.option(
+    "--export",
+    type=click.Path(dir_okay=False, writable=True),
+    help="Export complete tool configuration to file (format auto-detected from .json/.yaml extension)",
+)
 @output_flags()
 @click.pass_context
-def get(ctx, tool_ref, select):
-    """Get tool details."""
+def get(ctx, tool_ref, select, export):
+    """Get tool details.
+
+    Examples:
+        aip tools get my-tool
+        aip tools get my-tool --export tool.json    # Exports complete configuration as JSON
+        aip tools get my-tool --export tool.yaml    # Exports complete configuration as YAML
+    """
     try:
         client = get_client(ctx)
 
         # Resolve tool with ambiguity handling
         tool = _resolve_tool(ctx, client, tool_ref, select)
 
-        # Create result data with all available fields from backend
-        result_data = {
-            "id": str(getattr(tool, "id", "N/A")),
-            "name": getattr(tool, "name", "N/A"),
-            "tool_type": getattr(tool, "tool_type", "N/A"),
-            "framework": getattr(tool, "framework", "N/A"),
-            "version": getattr(tool, "version", "N/A"),
-            "description": getattr(tool, "description", "N/A"),
-        }
-
-        output_result(
-            ctx, result_data, title="Tool Details", panel_title=f"🔧 {tool.name}"
-        )
+        # Handle export option
+        if export:
+            export_path = Path(export)
+            # Auto-detect format from file extension
+            if export_path.suffix.lower() in [".yaml", ".yml"]:
+                detected_format = "yaml"
+            else:
+                detected_format = "json"
+
+            # Always export comprehensive data - re-fetch tool with full details if needed
+            try:
+                tool = client.get_tool_by_id(tool.id)
+            except Exception as e:
+                console.print(
+                    Text(f"[yellow]⚠️  Could not fetch full tool details: {e}[/yellow]")
+                )
+                console.print(
+                    Text("[yellow]⚠️  Proceeding with available data[/yellow]")
+                )
+
+            export_resource_to_file(tool, export_path, detected_format)
+            console.print(
+                Text(
+                    f"[green]✅ Complete tool configuration exported to: {export_path} (format: {detected_format})[/green]"
+                )
+            )
+
+        # Try to fetch raw API data first to preserve ALL fields
+        raw_tool_data = fetch_raw_resource_details(client, tool, "tools")
+
+        if raw_tool_data:
+            # Use raw API data - this preserves ALL fields
+            # Format dates for better display (minimal postprocessing)
+            formatted_data = raw_tool_data.copy()
+            if "created_at" in formatted_data:
+                formatted_data["created_at"] = format_datetime(
+                    formatted_data["created_at"]
+                )
+            if "updated_at" in formatted_data:
+                formatted_data["updated_at"] = format_datetime(
+                    formatted_data["updated_at"]
+                )
+
+            # Display using output_result with raw data
+            output_result(
+                ctx,
+                formatted_data,
+                title="Tool Details",
+                panel_title=f"🔧 {raw_tool_data.get('name', 'Unknown')}",
+            )
+        else:
+            # Fall back to original method if raw fetch fails
+            console.print("[yellow]Falling back to Pydantic model data[/yellow]")
+
+            # Create result data with all available fields from backend
+            result_data = {
+                "id": str(getattr(tool, "id", "N/A")),
+                "name": getattr(tool, "name", "N/A"),
+                "tool_type": getattr(tool, "tool_type", "N/A"),
+                "framework": getattr(tool, "framework", "N/A"),
+                "version": getattr(tool, "version", "N/A"),
+                "description": getattr(tool, "description", "N/A"),
+            }
+
+            output_result(
+                ctx, result_data, title="Tool Details", panel_title=f"🔧 {tool.name}"
+            )
 
     except Exception as e:
         raise click.ClickException(str(e))
@@ -248,7 +398,9 @@ def get(ctx, tool_ref, select):
 @tools_group.command()
 @click.argument("tool_id")
 @click.option(
-    "--file", type=click.Path(exists=True), help="New tool file for code update"
+    "--file",
+    type=click.Path(exists=True),
+    help="New tool file for code update (custom tools only)",
 )
 @click.option("--description", help="New description")
 @click.option("--tags", help="Comma-separated tags")
@@ -265,41 +417,44 @@ def update(ctx, tool_id, file, description, tags):
         except Exception as e:
             raise click.ClickException(f"Tool with ID '{tool_id}' not found: {e}")
 
+        # Prepare update data
         update_data = {}
-
         if description:
             update_data["description"] = description
-
         if tags:
             update_data["tags"] = [tag.strip() for tag in tags.split(",")]
 
         if file:
-            # Update code
-            updated_tool = tool.update(file_path=file)
-            if ctx.obj.get("view") != "json":
-                console.print(Text(f"[green]✓[/green] Tool code updated from {file}"))
+            # Update code via file upload (custom tools only)
+            if tool.tool_type != "custom":
+                raise click.ClickException(
+                    f"File updates are only supported for custom tools. Tool '{tool.name}' is of type '{tool.tool_type}'."
+                )
+            updated_tool = client.tools.update_tool_via_file(
+                tool.id, file, framework=tool.framework
+            )
+            handle_rich_output(
+                ctx, Text(f"[green]✓[/green] Tool code updated from {file}")
+            )
         elif update_data:
-            # Update metadata
+            # Update metadata only (native tools only)
+            if tool.tool_type != "native":
+                raise click.ClickException(
+                    f"Metadata updates are only supported for native tools. Tool '{tool.name}' is of type '{tool.tool_type}'."
+                )
             updated_tool = tool.update(**update_data)
-            if ctx.obj.get("view") != "json":
-                console.print(Text("[green]✓[/green] Tool metadata updated"))
+            handle_rich_output(ctx, Text("[green]✓[/green] Tool metadata updated"))
         else:
-            if ctx.obj.get("view") != "json":
-                console.print(Text("[yellow]No updates specified[/yellow]"))
+            handle_rich_output(ctx, Text("[yellow]No updates specified[/yellow]"))
             return
 
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps(updated_tool.model_dump(), indent=2))
-        else:
-            console.print(
-                f"[green]✅ Tool '{updated_tool.name}' updated successfully[/green]"
-            )
+        handle_json_output(ctx, updated_tool.model_dump())
+        handle_rich_output(ctx, display_update_success("Tool", updated_tool.name))
 
     except Exception as e:
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(Text(f"[red]Error updating tool: {e}[/red]"))
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            display_api_error(e, "tool update")
         raise click.ClickException(str(e))
 
 
@@ -319,37 +474,29 @@ def delete(ctx, tool_id, yes):
         except Exception as e:
             raise click.ClickException(f"Tool with ID '{tool_id}' not found: {e}")
 
-        # Confirm deletion
-        if not yes and not click.confirm(
-            f"Are you sure you want to delete tool '{tool.name}'?"
-        ):
-            if ctx.obj.get("view") != "json":
-                console.print(Text("Deletion cancelled."))
+        # Confirm deletion via centralized display helper
+        if not yes and not display_confirmation_prompt("Tool", tool.name):
             return
 
         tool.delete()
 
-        if ctx.obj.get("view") == "json":
-            click.echo(
-                json.dumps(
-                    {"success": True, "message": f"Tool '{tool.name}' deleted"},
-                    indent=2,
-                )
-            )
-        else:
-            console.print(
-                Text(f"[green]✅ Tool '{tool.name}' deleted successfully[/green]")
-            )
+        handle_json_output(
+            ctx,
+            {
+                "success": True,
+                "message": f"Tool '{tool.name}' deleted",
+            },
+        )
+        handle_rich_output(ctx, display_deletion_success("Tool", tool.name))
 
     except Exception as e:
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(Text(f"[red]Error deleting tool: {e}[/red]"))
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            display_api_error(e, "tool deletion")
         raise click.ClickException(str(e))
 
 
-@tools_group.command()
+@tools_group.command("script")
 @click.argument("tool_id")
 @output_flags()
 @click.pass_context
@@ -357,92 +504,16 @@ def script(ctx, tool_id):
     """Get tool script content."""
     try:
         client = get_client(ctx)
-
-        # Get tool by ID (no ambiguity handling needed)
-        try:
-            tool = client.get_tool_by_id(tool_id)
-        except Exception as e:
-            raise click.ClickException(f"Tool with ID '{tool_id}' not found: {e}")
-
-        # Get tool script content
-        script_content = client.tools.get_tool_script(tool_id)
-
-        if ctx.obj.get("view") == "json":
-            click.echo(
-                json.dumps(
-                    {
-                        "tool_id": tool_id,
-                        "tool_name": tool.name,
-                        "script": script_content,
-                    },
-                    indent=2,
-                )
-            )
-        elif ctx.obj.get("output"):
-            # Save to file
-            output_file = ctx.obj.get("output")
-            with open(output_file, "w", encoding="utf-8") as f:
-                f.write(script_content)
-            console.print(f"[green]✅ Tool script saved to {output_file}[/green]")
-        else:
-            # Display in terminal
-            console.print(
-                Panel(
-                    script_content,
-                    title=f"🔧 Tool Script: {tool.name}",
-                    border_style="cyan",
-                )
-            )
-
-    except Exception as e:
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(f"[red]Error getting tool script: {e}[/red]")
-        raise click.ClickException(str(e))
-
-
-@tools_group.command()
-@click.argument("tool_id")
-@click.option(
-    "--file",
-    type=click.Path(exists=True),
-    required=True,
-    help="New tool file for code update",
-)
-@click.option("--name", help="New tool name")
-@click.option("--description", help="New description")
-@click.option("--tags", help="Comma-separated tags")
-@output_flags()
-@click.pass_context
-def upload_update(ctx, tool_id, file, name, description, tags):
-    """Update a tool plugin via file upload."""
-    try:
-        client = get_client(ctx)
-
-        # Prepare update data
-        update_data = {}
-        if name:
-            update_data["name"] = name
-        if description:
-            update_data["description"] = description
-        if tags:
-            update_data["tags"] = [tag.strip() for tag in tags.split(",")]
-
-        # Update tool via file upload
-        updated_tool = client.tools.update_tool_via_file(tool_id, file, **update_data)
+        script_content = client.get_tool_script(tool_id)
 
         if ctx.obj.get("view") == "json":
-            click.echo(json.dumps(updated_tool.model_dump(), indent=2))
+            click.echo(json.dumps({"script": script_content}, indent=2))
         else:
-            console.print(
-                f"[green]✅ Tool '{updated_tool.name}' updated successfully via file upload[/green]"
-            )
-            console.print(f"[blue]📁 File: {file}[/blue]")
+            console.print(f"[green]📜 Tool Script for '{tool_id}':[/green]")
+            console.print(script_content)
 
     except Exception as e:
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(Text(f"[red]Error updating tool: {e}[/red]"))
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            console.print(Text(f"[red]Error getting tool script: {e}[/red]"))
         raise click.ClickException(str(e))