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

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 {}
 
@@ -191,16 +198,6 @@ def get_client(ctx) -> Client:
     )
 
 
-# ----------------------------- Small helpers ----------------------------- #
-
-
-def safe_getattr(obj: Any, attr: str, default: Any = None) -> Any:
-    try:
-        return getattr(obj, attr)
-    except Exception:
-        return default
-
-
 # ----------------------------- Secret masking ---------------------------- #
 
 _DEFAULT_MASK_FIELDS = {
@@ -481,8 +478,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
@@ -490,12 +485,12 @@ def output_result(
         return
 
     if success_message:
-        console.print(f"[green]✅ {success_message}[/green]")
+        console.print(Text(f"[green]✅ {success_message}[/green]"))
 
     if panel_title:
         console.print(Panel(Pretty(data), title=panel_title, border_style="blue"))
     else:
-        console.print(f"[cyan]{title}:[/cyan]")
+        console.print(Text(f"[cyan]{title}:[/cyan]"))
         console.print(Pretty(data))
 
 
@@ -532,6 +527,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]
@@ -563,7 +566,7 @@ def output_list(
         return
 
     if not items:
-        console.print(f"[yellow]No {title.lower()} found.[/yellow]")
+        console.print(Text(f"[yellow]No {title.lower()} found.[/yellow]"))
         return
 
     # Sort by name by default (unless disabled)
@@ -578,14 +581,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 +680,240 @@ 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)
+
+    # Configure renderer based on verbose mode and explicit overrides
+    if live is None:
+        live_enabled = not verbose  # Disable live mode in verbose (unless overridden)
+    else:
+        live_enabled = 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 _fuzzy_pick_for_resources(
+    resources: list[Any], resource_type: str, search_term: str
+) -> Any | None:
+    """
+    Fuzzy picker for resource objects, similar to _fuzzy_pick but without column dependencies.
+
+    Args:
+        resources: List of resource objects to choose from
+        resource_type: Type of resource (e.g., "agent", "tool")
+        search_term: The search term that led to multiple matches
+
+    Returns:
+        Selected resource object or None if cancelled/no selection
+    """
+    if not (_HAS_PTK and console.is_terminal and os.isatty(1)):
+        return None
+
+    # Build display corpus and a reverse map
+    labels = []
+    by_label: dict[str, Any] = {}
+    for resource in resources:
+        name = getattr(resource, "name", "Unknown")
+        _id = getattr(resource, "id", "Unknown")
+        # Create a display label similar to _row_display
+        label_parts = []
+        if name and name != "Unknown":
+            label_parts.append(name)
+        label_parts.append(f"[{_id[:8]}...]")  # Show first 8 chars of ID
+        label = " • ".join(label_parts)
+
+        # Ensure uniqueness
+        if label in by_label:
+            i = 2
+            base = label
+            while f"{base} #{i}" in by_label:
+                i += 1
+            label = f"{base} #{i}"
+        labels.append(label)
+        by_label[label] = resource
+
+    # Create fuzzy completer
+    class FuzzyCompleter:
+        def __init__(self, words: list[str]):
+            self.words = words
+
+        def get_completions(self, document, complete_event):
+            word = document.get_word_before_cursor()
+            if not word:
+                return
+
+            word_lower = word.lower()
+            for label in self.words:
+                label_lower = label.lower()
+                # Fuzzy match logic
+                if self._fuzzy_match(word_lower, label_lower):
+                    yield Completion(label, start_position=-len(word))
+
+        def _fuzzy_match(self, search: str, target: str) -> bool:
+            if not search:
+                return True
+
+            search_idx = 0
+            for char in target:
+                if search_idx < len(search) and search[search_idx] == char:
+                    search_idx += 1
+                    if search_idx == len(search):
+                        return True
+            return False
+
+    completer = FuzzyCompleter(labels)
+
+    try:
+        answer = prompt(
+            message=f"Find 🤖 {resource_type.title()}: ",
+            completer=completer,
+            complete_in_thread=True,
+            complete_while_typing=True,
+        )
+    except (KeyboardInterrupt, EOFError):
+        return None
+
+    if not answer:
+        return None
+
+    # Exact label match
+    if answer in by_label:
+        return by_label[answer]
+
+    # Fuzzy search fallback
+    best_match = None
+    best_score = -1
+
+    for label in labels:
+        score = _fuzzy_score(answer.lower(), label.lower())
+        if score > best_score:
+            best_score = score
+            best_match = label
+
+    if best_match and best_score > 0:
+        return by_label[best_match]
+
+    return None
+
+
+def resolve_resource(
+    ctx,
+    ref: str,
+    *,
+    get_by_id,
+    find_by_name,
+    label: str,
+    select: int | None = None,
+    interface_preference: str = "fuzzy",
+):
+    """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
+        interface_preference: "fuzzy" for fuzzy picker, "questionary" for up/down list
+
+    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]
+
+    # Choose interface based on preference
+    if interface_preference == "fuzzy":
+        # Use fuzzy picker for modern UX
+        picked = _fuzzy_pick_for_resources(matches, label.lower(), ref)
+        if picked:
+            return picked
+        # Fallback to original ambiguity handler if fuzzy picker fails
+        return handle_ambiguous_resource(ctx, label.lower(), ref, matches)
+    else:
+        # Use questionary interface for traditional up/down selection
+        return handle_ambiguous_resource(ctx, label.lower(), ref, matches)
+
+
 def handle_ambiguous_resource(
     ctx, resource_type: str, ref: str, matches: list[Any]
 ) -> Any:
@@ -712,7 +941,9 @@ def handle_ambiguous_resource(
 
     # Fallback numeric prompt
     console.print(
-        f"[yellow]Multiple {resource_type.replace('{', '{{').replace('}', '}}')}s found matching '{ref.replace('{', '{{').replace('}', '}}')}':[/yellow]"
+        Text(
+            f"[yellow]Multiple {resource_type.replace('{', '{{').replace('}', '}}')}s found matching '{ref.replace('{', '{{').replace('}', '}}')}':[/yellow]"
+        )
     )
     table = Table(
         title=f"Select {resource_type.replace('{', '{{').replace('}', '}}').title()}",

glaip_sdk/client/__init__.py

@@ -5,6 +5,8 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from typing import Any
+
 from glaip_sdk.client.agents import AgentClient
 from glaip_sdk.client.base import BaseClient
 from glaip_sdk.client.mcps import MCPClient
@@ -104,10 +106,18 @@ class Client(BaseClient):
         return tool
 
     def create_tool_from_code(
-        self, name: str, code: str, framework: str = "langchain"
+        self,
+        name: str,
+        code: str,
+        framework: str = "langchain",
+        *,
+        description: str | None = None,
+        tags: list[str] | None = None,
     ) -> Tool:
         """Create a new tool plugin from code string."""
-        tool = self.tools.create_tool_from_code(name, code, framework)
+        tool = self.tools.create_tool_from_code(
+            name, code, framework, description=description, tags=tags
+        )
         tool._set_client(self)
         return tool
 
@@ -119,6 +129,16 @@ class Client(BaseClient):
         """Delete a tool by ID."""
         return self.tools.delete_tool(tool_id)
 
+    def get_tool_script(self, tool_id: str) -> str:
+        """Get tool script content."""
+        return self.tools.get_tool_script(tool_id)
+
+    def update_tool_via_file(self, tool_id: str, file_path: str, **kwargs) -> Tool:
+        """Update a tool plugin via file upload."""
+        tool = self.tools.update_tool_via_file(tool_id, file_path, **kwargs)
+        tool._set_client(self)
+        return tool
+
     # ---- MCPs
     def list_mcps(self) -> list[MCP]:
         mcps = self.mcps.list_mcps()
@@ -150,6 +170,18 @@ class Client(BaseClient):
         """Update an MCP by ID."""
         return self.mcps.update_mcp(mcp_id, **kwargs)
 
+    def test_mcp_connection(self, config: dict[str, Any]) -> dict[str, Any]:
+        """Test MCP connection using configuration."""
+        return self.mcps.test_mcp_connection(config)
+
+    def test_mcp_connection_from_config(self, config: dict[str, Any]) -> dict[str, Any]:
+        """Test MCP connection using configuration (alias)."""
+        return self.mcps.test_mcp_connection_from_config(config)
+
+    def get_mcp_tools_from_config(self, config: dict[str, Any]) -> list[dict[str, Any]]:
+        """Fetch tools from MCP configuration without saving."""
+        return self.mcps.get_mcp_tools_from_config(config)
+
     def run_agent(self, agent_id: str, message: str, **kwargs) -> str:
         """Run an agent with a message."""
         return self.agents.run_agent(agent_id, message, **kwargs)
@@ -160,6 +192,26 @@ class Client(BaseClient):
         data = self._request("GET", "/language-models")
         return data or []
 
+    # ---- Timeout propagation ----
+    @property
+    def timeout(self) -> float:  # type: ignore[override]
+        return super().timeout
+
+    @timeout.setter
+    def timeout(self, value: float) -> None:  # type: ignore[override]
+        # Rebuild the root http client
+        BaseClient.timeout.fset(self, value)  # call parent setter
+        # Propagate the new session to sub-clients so they don't hold a closed client
+        try:
+            if hasattr(self, "agents"):
+                self.agents.http_client = self.http_client
+            if hasattr(self, "tools"):
+                self.tools.http_client = self.http_client
+            if hasattr(self, "mcps"):
+                self.mcps.http_client = self.http_client
+        except Exception:
+            pass
+
     # ---- Aliases (back-compat)
     def get_agent(self, agent_id: str) -> Agent:
         return self.get_agent_by_id(agent_id)