glaip-sdk 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

glaip_sdk/cli/commands/tools.py

@@ -5,19 +5,20 @@ Authors:
 """
 
 import json
+import re
 
 import click
 from rich.console import Console
 from rich.panel import Panel
-
-from glaip_sdk.utils import is_uuid
+from rich.text import Text
 
 from ..utils import (
+    coerce_to_row,
     get_client,
-    handle_ambiguous_resource,
     output_flags,
     output_list,
     output_result,
+    resolve_resource,
 )
 
 console = Console()
@@ -31,25 +32,61 @@ def tools_group():
 
 def _resolve_tool(ctx, client, ref, select=None):
     """Resolve tool reference (ID or name) with ambiguity handling."""
-    if is_uuid(ref):
-        return client.get_tool(ref)
-
-    # Use find_tools for name-based resolution
-    matches = client.find_tools(name=ref)
-    if not matches:
-        raise click.ClickException(f"Tool not found: {ref}")
-
-    if len(matches) == 1:
-        return matches[0]
-    elif len(matches) > 1:
-        if select:
-            idx = int(select) - 1
-            if not (0 <= idx < len(matches)):
-                raise click.ClickException(f"--select must be 1..{len(matches)}")
-            return matches[idx]
-        return handle_ambiguous_resource(ctx, "tool", ref, matches)
-    else:
-        raise click.ClickException(f"Tool not found: {ref}")
+    return resolve_resource(
+        ctx,
+        ref,
+        get_by_id=client.get_tool,
+        find_by_name=client.find_tools,
+        label="Tool",
+        select=select,
+    )
+
+
+# ----------------------------- Helpers --------------------------------- #
+
+
+def _extract_internal_name(code: str) -> str:
+    """Extract plugin class name attribute from tool code."""
+    m = re.search(r'^\s*name\s*:\s*str\s*=\s*"([^"]+)"', code, re.M)
+    if not m:
+        m = re.search(r'^\s*name\s*=\s*"([^"]+)"', code, re.M)
+    if not m:
+        raise click.ClickException(
+            "Could not find plugin 'name' attribute in the tool file. "
+            'Ensure your plugin class defines e.g. name: str = "my_tool".'
+        )
+    return m.group(1)
+
+
+def _validate_name_match(provided: str | None, internal: str) -> str:
+    """Validate provided --name against internal name; return effective name."""
+    if provided and provided != internal:
+        raise click.ClickException(
+            f"--name '{provided}' does not match plugin internal name '{internal}'. "
+            "Either update the code or pass a matching --name."
+        )
+    return provided or internal
+
+
+def _check_duplicate_name(client, tool_name: str) -> None:
+    """Raise if a tool with the same name already exists."""
+    try:
+        existing = client.find_tools(name=tool_name)
+        if existing:
+            raise click.ClickException(
+                f"A tool named '{tool_name}' already exists. "
+                "Please change your plugin's 'name' to a unique value, then re-run."
+            )
+    except click.ClickException:
+        # Re-raise ClickException (intended error)
+        raise
+    except Exception:
+        # Non-fatal: best-effort duplicate check for other errors
+        pass
+
+
+def _parse_tags(tags: str | None) -> list[str]:
+    return [t.strip() for t in (tags.split(",") if tags else []) if t.strip()]
 
 
 @tools_group.command(name="list")
@@ -70,20 +107,10 @@ def list_tools(ctx):
 
         # Transform function for safe dictionary access
         def transform_tool(tool):
-            # Handle both dict and object formats
-            if isinstance(tool, dict):
-                return {
-                    "id": str(tool.get("id", "N/A")),
-                    "name": tool.get("name", "N/A"),
-                    "framework": tool.get("framework", "N/A"),
-                }
-            else:
-                # Fallback to attribute access
-                return {
-                    "id": str(getattr(tool, "id", "N/A")),
-                    "name": getattr(tool, "name", "N/A"),
-                    "framework": getattr(tool, "framework", "N/A"),
-                }
+            row = coerce_to_row(tool, ["id", "name", "framework"])
+            # Ensure id is always a string
+            row["id"] = str(row["id"])
+            return row
 
         output_list(ctx, tools, "🔧 Available Tools", columns, transform_tool)
 
@@ -92,6 +119,7 @@ def list_tools(ctx):
 
 
 @tools_group.command()
+@click.argument("file_arg", required=False, type=click.Path(exists=True))
 @click.option(
     "--file",
     type=click.Path(exists=True),
@@ -111,11 +139,15 @@ def list_tools(ctx):
 )
 @output_flags()
 @click.pass_context
-def create(ctx, file, name, description, tags):
+def create(ctx, file_arg, file, name, description, tags):
     """Create a new tool."""
     try:
         client = get_client(ctx)
 
+        # 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:
             # Metadata-only tool creation
@@ -126,27 +158,33 @@ def create(ctx, file, name, description, tags):
 
         # Create tool based on whether file is provided
         if file:
-            # File-based tool creation - use create_tool_from_code for proper plugin processing
+            # File-based tool creation — validate internal plugin name, no rewriting
             with open(file, encoding="utf-8") as f:
                 code_content = f.read()
 
-            # Extract name from file if not provided
-            if not name:
-                import os
-
-                name = os.path.splitext(os.path.basename(file))[0]
-
-            # Create tool plugin using the upload endpoint
-            tool = client.create_tool_from_code(name, code_content)
+            internal_name = _extract_internal_name(code_content)
+            tool_name = _validate_name_match(name, internal_name)
+            _check_duplicate_name(client, tool_name)
+
+            # Upload the plugin code as-is (no rewrite)
+            tool = client.create_tool_from_code(
+                tool_name,
+                code_content,
+                framework="langchain",  # Always langchain
+                description=description,
+                tags=_parse_tags(tags),
+            )
         else:
             # Metadata-only tool creation
             tool_kwargs = {}
             if name:
                 tool_kwargs["name"] = name
+            tool_kwargs["tool_type"] = "custom"  # Always custom
+            tool_kwargs["framework"] = "langchain"  # Always langchain
             if description:
                 tool_kwargs["description"] = description
             if tags:
-                tool_kwargs["tags"] = [tag.strip() for tag in tags.split(",")]
+                tool_kwargs["tags"] = _parse_tags(tags)
 
             tool = client.create_tool(**tool_kwargs)
 
@@ -160,8 +198,8 @@ def create(ctx, file, name, description, tags):
             panel = Panel(
                 f"[green]✅ Tool '{tool.name}' created successfully via {creation_method}![/green]\n\n"
                 f"ID: {tool.id}\n"
-                f"Framework: langchain (default)\n"
-                f"Type: {'custom' if file else 'native'} (auto-detected)\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",
@@ -172,7 +210,7 @@ def create(ctx, file, name, description, tags):
         if ctx.obj.get("view") == "json":
             click.echo(json.dumps({"error": str(e)}, indent=2))
         else:
-            console.print(f"[red]Error creating tool: {e}[/red]")
+            console.print(Text(f"[red]Error creating tool: {e}[/red]"))
         raise click.ClickException(str(e))
 
 
@@ -239,15 +277,15 @@ def update(ctx, tool_id, file, description, tags):
             # Update code
             updated_tool = tool.update(file_path=file)
             if ctx.obj.get("view") != "json":
-                console.print(f"[green]✓[/green] Tool code updated from {file}")
+                console.print(Text(f"[green]✓[/green] Tool code updated from {file}"))
         elif update_data:
             # Update metadata
             updated_tool = tool.update(**update_data)
             if ctx.obj.get("view") != "json":
-                console.print("[green]✓[/green] Tool metadata updated")
+                console.print(Text("[green]✓[/green] Tool metadata updated"))
         else:
             if ctx.obj.get("view") != "json":
-                console.print("[yellow]No updates specified[/yellow]")
+                console.print(Text("[yellow]No updates specified[/yellow]"))
             return
 
         if ctx.obj.get("view") == "json":
@@ -261,7 +299,7 @@ def update(ctx, tool_id, file, description, tags):
         if ctx.obj.get("view") == "json":
             click.echo(json.dumps({"error": str(e)}, indent=2))
         else:
-            console.print(f"[red]Error updating tool: {e}[/red]")
+            console.print(Text(f"[red]Error updating tool: {e}[/red]"))
         raise click.ClickException(str(e))
 
 
@@ -286,7 +324,7 @@ def delete(ctx, tool_id, yes):
             f"Are you sure you want to delete tool '{tool.name}'?"
         ):
             if ctx.obj.get("view") != "json":
-                console.print("Deletion cancelled.")
+                console.print(Text("Deletion cancelled."))
             return
 
         tool.delete()
@@ -299,11 +337,112 @@ def delete(ctx, tool_id, yes):
                 )
             )
         else:
-            console.print(f"[green]✅ Tool '{tool.name}' deleted successfully[/green]")
+            console.print(
+                Text(f"[green]✅ Tool '{tool.name}' deleted successfully[/green]")
+            )
+
+    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]"))
+        raise click.ClickException(str(e))
+
+
+@tools_group.command()
+@click.argument("tool_id")
+@output_flags()
+@click.pass_context
+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)
+
+        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 via file upload[/green]"
+            )
+            console.print(f"[blue]📁 File: {file}[/blue]")
 
     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 deleting tool: {e}[/red]")
+            console.print(Text(f"[red]Error updating tool: {e}[/red]"))
         raise click.ClickException(str(e))

glaip_sdk/cli/main.py

@@ -4,20 +4,33 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+import os
+import subprocess
 import sys
 
 import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
 
+from glaip_sdk import Client
+from glaip_sdk._version import __version__ as _SDK_VERSION
+from glaip_sdk.branding import AIPBranding
 from glaip_sdk.cli.commands.agents import agents_group
-from glaip_sdk.cli.commands.configure import config_group, configure_command
+from glaip_sdk.cli.commands.configure import (
+    config_group,
+    configure_command,
+    load_config,
+)
 from glaip_sdk.cli.commands.init import init_command
 from glaip_sdk.cli.commands.mcps import mcps_group
 from glaip_sdk.cli.commands.models import models_group
 from glaip_sdk.cli.commands.tools import tools_group
+from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
 
 
 @click.group()
-@click.version_option(version="0.1.1", prog_name="aip")
+@click.version_option(version=_SDK_VERSION, prog_name="aip")
 @click.option("--api-url", envvar="AIP_API_URL", help="AIP API URL")
 @click.option("--api-key", envvar="AIP_API_KEY", help="AIP API Key")
 @click.option("--timeout", default=30.0, help="Request timeout in seconds")
@@ -37,11 +50,12 @@ def main(ctx, api_url, api_key, timeout, view, no_tty):
     agents, tools, MCPs, and more.
 
     Examples:
+        aip version                     # Show detailed version info
         aip configure                   # Configure credentials
+        aip init                         # Initialize configuration
         aip agents list                   # List all agents
         aip tools create my_tool.py      # Create a new tool
-        aip agents run my-agent "Hello"  # Run an agent
-        aip init                         # Initialize configuration
+        aip agents run my-agent "Hello world"  # Run an agent
     """
 
     # Store configuration in context
@@ -75,21 +89,19 @@ def status(ctx):
     """Show connection status and basic info."""
     config = {}
     try:
-        from rich.console import Console
-        from rich.panel import Panel
-        from rich.table import Table
-
-        from glaip_sdk import Client
-        from glaip_sdk.cli.commands.configure import load_config
-
         console = Console()
 
+        # Display AIP status banner
+        branding = AIPBranding.create_from_sdk(
+            sdk_version=_SDK_VERSION, package_name="glaip-sdk"
+        )
+        branding.display_status_banner("ready")
+
         # Load config from file and merge with context
         file_config = load_config()
         context_config = ctx.obj or {}
 
         # Load environment variables (middle priority)
-        import os
 
         env_config = {}
         if os.getenv("AIP_API_URL"):
@@ -146,7 +158,7 @@ def status(ctx):
                 Panel(
                     f"[bold green]✅ Connected to AIP Platform[/bold green]\n"
                     f"🔗 API URL: {client.api_url}\n"
-                    f"⏱️  Timeout: {config.get('timeout', 30.0)}s",
+                    f"🤖 Agent Run Timeout: {DEFAULT_AGENT_RUN_TIMEOUT}s",
                     title="🚀 Connection Status",
                     border_style="green",
                 )
@@ -191,9 +203,10 @@ def status(ctx):
 @main.command()
 def version():
     """Show version information."""
-    from glaip_sdk.config.constants import SDK_VERSION
-
-    click.echo(f"aip version {SDK_VERSION}")
+    branding = AIPBranding.create_from_sdk(
+        sdk_version=_SDK_VERSION, package_name="glaip-sdk"
+    )
+    branding.display_version_panel()
 
 
 @main.command()
@@ -201,17 +214,13 @@ def version():
     "--check-only", is_flag=True, help="Only check for updates without installing"
 )
 @click.option(
-    "--force", is_flag=True, help="Force update even if no new version available"
+    "--force",
+    is_flag=True,
+    help="Force reinstall even if already up-to-date (adds --force-reinstall)",
 )
 def update(check_only: bool, force: bool):
     """Update AIP SDK to the latest version from PyPI."""
     try:
-        import subprocess
-        import sys
-
-        from rich.console import Console
-        from rich.panel import Panel
-
         console = Console()
 
         if check_only:
@@ -238,12 +247,17 @@ def update(check_only: bool, force: bool):
 
         # Update using pip
         try:
-            subprocess.run(
-                [sys.executable, "-m", "pip", "install", "--upgrade", "glaip-sdk"],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
+            cmd = [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "--upgrade",
+                "glaip-sdk",
+            ]
+            if force:
+                cmd.insert(5, "--force-reinstall")
+            subprocess.run(cmd, capture_output=True, text=True, check=True)
 
             console.print(
                 Panel(