glaip-sdk 0.0.1b10__py3-none-any.whl → 0.0.3__py3-none-any.whl

glaip_sdk/cli/commands/tools.py

@@ -5,19 +5,19 @@ 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 ..utils import (
+    coerce_to_row,
     get_client,
-    handle_ambiguous_resource,
     output_flags,
     output_list,
     output_result,
+    resolve_resource,
 )
 
 console = Console()
@@ -31,25 +31,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 +106,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 +118,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 +138,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 +157,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 +197,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",
@@ -307,3 +344,102 @@ def delete(ctx, tool_id, yes):
         else:
             console.print(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 updating tool: {e}[/red]")
+        raise click.ClickException(str(e))

glaip_sdk/cli/main.py

@@ -4,20 +4,32 @@ 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.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")
@@ -75,13 +87,6 @@ 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()
 
         # Load config from file and merge with context
@@ -89,7 +94,6 @@ def status(ctx):
         context_config = ctx.obj or {}
 
         # Load environment variables (middle priority)
-        import os
 
         env_config = {}
         if os.getenv("AIP_API_URL"):
@@ -146,7 +150,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 +195,7 @@ 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}")
+    click.echo(f"aip version {_SDK_VERSION}")
 
 
 @main.command()
@@ -201,17 +203,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 +236,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(

glaip_sdk/cli/utils.py

@@ -19,6 +19,7 @@ from typing import TYPE_CHECKING, Any
 import click
 from rich import box
 from rich.console import Console, Group
+from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.pretty import Pretty
 from rich.table import Table
@@ -41,6 +42,15 @@ except Exception:
 if TYPE_CHECKING:
     from glaip_sdk import Client
 
+from glaip_sdk import Client
+from glaip_sdk.cli.commands.configure import load_config
+from glaip_sdk.utils import is_uuid
+from glaip_sdk.utils.rendering.renderer import (
+    CapturingConsole,
+    RendererConfig,
+    RichStreamRenderer,
+)
+
 console = Console()
 
 
@@ -160,9 +170,6 @@ def _get_view(ctx) -> str:
 
 def get_client(ctx) -> Client:
     """Get configured client from context, env, and config file (ctx > env > file)."""
-    from glaip_sdk import Client
-    from glaip_sdk.cli.commands.configure import load_config
-
     file_config = load_config() or {}
     context_config = (ctx.obj or {}) if ctx else {}
 
@@ -481,8 +488,6 @@ def output_result(
 
     if fmt == "md":
         try:
-            from rich.markdown import Markdown
-
             console.print(Markdown(str(data)))
         except ImportError:
             # Fallback to plain if markdown not available
@@ -532,6 +537,14 @@ def output_list(
     except Exception:
         rows = []
 
+    # Mask secrets (apply before any view)
+    mask_fields = _resolve_mask_fields()
+    if mask_fields:
+        try:
+            rows = [_maybe_mask_row(r, mask_fields) for r in rows]
+        except Exception:
+            pass
+
     # JSON view bypasses any UI
     if fmt == "json":
         data = rows or [it.to_dict() if hasattr(it, "to_dict") else it for it in items]
@@ -578,14 +591,6 @@ def output_list(
         except Exception:
             pass
 
-    # Mask secrets
-    mask_fields = _resolve_mask_fields()
-    if mask_fields:
-        try:
-            rows = [_maybe_mask_row(r, mask_fields) for r in rows]
-        except Exception:
-            pass
-
     # === Fuzzy palette is the default for TTY lists ===
     picked: dict[str, Any] | None = None
     if console.is_terminal and os.isatty(1):
@@ -685,6 +690,114 @@ def output_flags():
 # ------------------------- Ambiguity handling --------------------------- #
 
 
+def coerce_to_row(item, keys: list[str]) -> dict[str, Any]:
+    """Coerce an item (dict or object) to a row dict with specified keys.
+
+    Args:
+        item: The item to coerce (dict or object with attributes)
+        keys: List of keys/attribute names to extract
+
+    Returns:
+        Dict with the extracted values, "N/A" for missing values
+    """
+    result = {}
+    for key in keys:
+        if isinstance(item, dict):
+            value = item.get(key, "N/A")
+        else:
+            value = getattr(item, key, "N/A")
+        result[key] = str(value) if value is not None else "N/A"
+    return result
+
+
+def build_renderer(
+    ctx,
+    *,
+    save_path,
+    theme="dark",
+    verbose=False,
+    tty_enabled=True,
+    live=None,
+    snapshots=None,
+):
+    """Build renderer and capturing console for CLI commands.
+
+    Args:
+        ctx: Click context
+        save_path: Path to save output to (enables capturing)
+        theme: Color theme ("dark" or "light")
+        verbose: Whether to enable verbose mode
+        tty_enabled: Whether TTY is available
+
+    Returns:
+        Tuple of (renderer, capturing_console)
+    """
+    # Use capturing console if saving output
+    working_console = console
+    if save_path:
+        working_console = CapturingConsole(console, capture=True)
+
+    # Decide live behavior: default is live unless verbose; allow explicit override
+    live_enabled = (not verbose) if live is None else bool(live)
+    renderer_cfg = RendererConfig(
+        theme=theme,
+        style="debug" if verbose else "pretty",
+        live=live_enabled,
+        show_delegate_tool_panels=True,
+        append_finished_snapshots=bool(snapshots)
+        if snapshots is not None
+        else RendererConfig.append_finished_snapshots,
+    )
+
+    # Create the renderer instance
+    renderer = RichStreamRenderer(
+        working_console.original_console
+        if isinstance(working_console, CapturingConsole)
+        else working_console,
+        cfg=renderer_cfg,
+        verbose=verbose,
+    )
+
+    return renderer, working_console
+
+
+def resolve_resource(
+    ctx, ref: str, *, get_by_id, find_by_name, label: str, select: int | None = None
+):
+    """Resolve resource reference (ID or name) with ambiguity handling.
+
+    Args:
+        ctx: Click context
+        ref: Resource reference (ID or name)
+        get_by_id: Function to get resource by ID
+        find_by_name: Function to find resources by name
+        label: Resource type label for error messages
+        select: Optional selection index for ambiguity resolution
+
+    Returns:
+        Resolved resource object
+    """
+    if is_uuid(ref):
+        return get_by_id(ref)
+
+    # Find resources by name
+    matches = find_by_name(name=ref)
+    if not matches:
+        raise click.ClickException(f"{label} '{ref}' not found")
+
+    if len(matches) == 1:
+        return matches[0]
+
+    # Multiple matches - handle ambiguity
+    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, label.lower(), ref, matches)
+
+
 def handle_ambiguous_resource(
     ctx, resource_type: str, ref: str, matches: list[Any]
 ) -> Any: