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

glaip_sdk/cli/utils.py

@@ -17,12 +17,9 @@ import tempfile
 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
 from rich.text import Text
 
 # Optional interactive deps (fuzzy palette)
@@ -44,6 +41,7 @@ if TYPE_CHECKING:
 
 from glaip_sdk import Client
 from glaip_sdk.cli.commands.configure import load_config
+from glaip_sdk.rich_components import AIPPanel, AIPTable
 from glaip_sdk.utils import is_uuid
 from glaip_sdk.utils.rendering.renderer import (
     CapturingConsole,
@@ -57,7 +55,9 @@ console = Console()
 # ----------------------------- Pager helpers ----------------------------- #
 
 
-def _prepare_pager_env(clear_on_exit: bool = True) -> None:
+def _prepare_pager_env(
+    clear_on_exit: bool = True,
+) -> None:  # pragma: no cover - terminal UI setup
     """
     Configure LESS flags for a predictable, high-quality UX:
       -R  : pass ANSI color escapes
@@ -74,7 +74,9 @@ def _prepare_pager_env(clear_on_exit: bool = True) -> None:
         os.environ["LESS"] = os.getenv("AIP_LESS_FLAGS", default_flags)
 
 
-def _render_ansi(renderable) -> str:
+def _render_ansi(
+    renderable,
+) -> str:  # pragma: no cover - rendering requires real terminal
     """Render a Rich renderable to an ANSI string suitable for piping to 'less'."""
     buf = io.StringIO()
     tmp_console = Console(
@@ -90,7 +92,7 @@ def _render_ansi(renderable) -> str:
     return buf.getvalue()
 
 
-def _pager_header() -> str:
+def _pager_header() -> str:  # pragma: no cover - terminal UI helper
     v = (os.getenv("AIP_PAGER_HEADER", "1") or "1").strip().lower()
     if v in {"0", "false", "off"}:
         return ""
@@ -103,7 +105,9 @@ def _pager_header() -> str:
     )
 
 
-def _page_with_system_pager(ansi_text: str) -> bool:
+def _page_with_system_pager(
+    ansi_text: str,
+) -> bool:  # pragma: no cover - spawns real pager
     """Prefer 'less' with a temp file so stdin remains the TTY."""
     if not (console.is_terminal and os.isatty(1)):
         return False
@@ -161,7 +165,7 @@ def _page_with_system_pager(ansi_text: str) -> bool:
 
 
 def _get_view(ctx) -> str:
-    obj = ctx.obj or {}
+    obj = (ctx.obj or {}) if ctx is not None else {}
     return obj.get("view") or obj.get("format") or "rich"
 
 
@@ -173,13 +177,20 @@ def get_client(ctx) -> Client:
     file_config = load_config() or {}
     context_config = (ctx.obj or {}) if ctx else {}
 
+    raw_timeout = os.getenv("AIP_TIMEOUT", "0") or "0"
+    try:
+        timeout_value = float(raw_timeout)
+    except ValueError:
+        timeout_value = None
+
     env_config = {
         "api_url": os.getenv("AIP_API_URL"),
         "api_key": os.getenv("AIP_API_KEY"),
-        "timeout": float(os.getenv("AIP_TIMEOUT", "0") or 0) or None,
+        "timeout": timeout_value if timeout_value else None,
     }
     env_config = {k: v for k, v in env_config.items() if v not in (None, "", 0)}
 
+    # Merge config sources: context > env > file
     config = {
         **file_config,
         **env_config,
@@ -220,28 +231,22 @@ def _mask_value(v: Any) -> str:
     return f"{s[:4]}••••••••{s[-4:]}"
 
 
-def _mask_any(x: Any, mask_fields: set[str]) -> Any:
-    """Recursively mask sensitive fields in any data structure.
-
-    Args:
-        x: The data to mask (dict, list, or primitive)
-        mask_fields: Set of field names to mask (case-insensitive)
+def _mask_any(value: Any, mask_fields: set[str]) -> Any:
+    """Recursively mask sensitive fields in mappings / lists."""
 
-    Returns:
-        Masked copy of the data with sensitive values replaced
-    """
-    if isinstance(x, dict):
-        out = {}
-        for k, v in x.items():
-            if k.lower() in mask_fields and v is not None:
-                out[k] = _mask_value(v)
+    if isinstance(value, dict):
+        masked: dict[Any, Any] = {}
+        for key, raw in value.items():
+            if isinstance(key, str) and key.lower() in mask_fields and raw is not None:
+                masked[key] = _mask_value(raw)
             else:
-                out[k] = _mask_any(v, mask_fields)
-        return out
-    elif isinstance(x, list):
-        return [_mask_any(v, mask_fields) for v in x]
-    else:
-        return x
+                masked[key] = _mask_any(raw, mask_fields)
+        return masked
+
+    if isinstance(value, list):
+        return [_mask_any(item, mask_fields) for item in value]
+
+    return value
 
 
 def _maybe_mask_row(row: dict[str, Any], mask_fields: set[str]) -> dict[str, Any]:
@@ -297,19 +302,18 @@ def _row_display(row: dict[str, Any], columns: list[tuple]) -> str:
     return " • ".join(parts) if parts else (_id or "(row)")
 
 
-def _fuzzy_pick(
-    rows: list[dict[str, Any]], columns: list[tuple], title: str
-) -> dict[str, Any] | None:
-    """
-    Open a minimal fuzzy palette using prompt_toolkit.
-    Returns the selected row (dict) or None if cancelled/missing deps.
-    """
-    if not (_HAS_PTK and console.is_terminal and os.isatty(1)):
-        return None
+def _check_fuzzy_pick_requirements() -> bool:
+    """Check if fuzzy picking requirements are met."""
+    return _HAS_PTK and console.is_terminal and os.isatty(1)
 
-    # Build display corpus and a reverse map
+
+def _build_unique_labels(
+    rows: list[dict[str, Any]], columns: list[tuple]
+) -> tuple[list[str], dict[str, dict[str, Any]]]:
+    """Build unique display labels and reverse mapping."""
     labels = []
     by_label: dict[str, dict[str, Any]] = {}
+
     for r in rows:
         label = _row_display(r, columns)
         # Ensure uniqueness: if duplicate, suffix with …#n
@@ -322,64 +326,49 @@ def _fuzzy_pick(
         labels.append(label)
         by_label[label] = r
 
-    # Create a fuzzy completer that searches anywhere in the string
-    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()
-                # Check if all characters in the search word appear in order in the label
-                if self._fuzzy_match(word_lower, label_lower):
-                    yield Completion(label, start_position=-len(word))
-
-        def _fuzzy_match(self, search: str, target: str) -> bool:
-            """
-            True fuzzy matching: checks if all characters in search appear in order in target.
-            Examples:
-            - "aws" matches "aws_calculator_agent" ✓
-            - "calc" matches "aws_calculator_agent" ✓
-            - "gent" matches "aws_calculator_agent" ✓
-            - "agent" matches "aws_calculator_agent" ✓
-            - "aws_calc" matches "aws_calculator_agent" ✓
-            """
-            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)
+    return labels, by_label
 
-    try:
-        answer = prompt(
-            message=f"Find {title.rstrip('s')}: ",
-            completer=completer,
-            complete_in_thread=True,
-            complete_while_typing=True,
-        )
-    except (KeyboardInterrupt, EOFError):
-        return None
 
-    if not answer:
-        return None
+class _FuzzyCompleter:
+    """Fuzzy completer for prompt_toolkit."""
 
-    # Exact label chosen from menu → direct hit
+    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()
+            if self._fuzzy_match(word_lower, label_lower):
+                yield Completion(label, start_position=-len(word))
+
+    def _fuzzy_match(self, search: str, target: str) -> bool:
+        """True fuzzy matching: checks if all characters in search appear in order in target."""
+        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
+
+
+def _perform_fuzzy_search(
+    answer: str, labels: list[str], by_label: dict[str, dict[str, Any]]
+) -> dict[str, Any] | None:
+    """Perform fuzzy search fallback and return best match."""
+    # Exact label match
     if answer in by_label:
         return by_label[answer]
 
-    # Fuzzy search fallback: find best fuzzy match
+    # Fuzzy search fallback
     best_match = None
     best_score = -1
 
@@ -389,11 +378,36 @@ def _fuzzy_pick(
             best_score = score
             best_match = label
 
-    if best_match and best_score > 0:
-        return by_label[best_match]
+    return by_label[best_match] if best_match and best_score > 0 else None
+
+
+def _fuzzy_pick(
+    rows: list[dict[str, Any]], columns: list[tuple], title: str
+) -> dict[str, Any] | None:  # pragma: no cover - requires interactive prompt toolkit
+    """
+    Open a minimal fuzzy palette using prompt_toolkit.
+    Returns the selected row (dict) or None if cancelled/missing deps.
+    """
+    if not _check_fuzzy_pick_requirements():
+        return None
+
+    # Build display labels and mapping
+    labels, by_label = _build_unique_labels(rows, columns)
+
+    # Create fuzzy completer
+    completer = _FuzzyCompleter(labels)
+
+    try:
+        answer = prompt(
+            message=f"Find {title.rstrip('s')}: ",
+            completer=completer,
+            complete_in_thread=True,
+            complete_while_typing=True,
+        )
+    except (KeyboardInterrupt, EOFError):
+        return None
 
-    # No match
-    return None
+    return _perform_fuzzy_search(answer, labels, by_label) if answer else None
 
 
 def _fuzzy_score(search: str, target: str) -> int:
@@ -450,6 +464,52 @@ def _fuzzy_score(search: str, target: str) -> int:
 # ----------------------------- Pretty outputs ---------------------------- #
 
 
+def _coerce_result_payload(result: Any) -> Any:
+    try:
+        to_dict = getattr(result, "to_dict", None)
+        if callable(to_dict):
+            return to_dict()
+    except Exception:
+        return result
+    return result
+
+
+def _apply_mask_if_configured(payload: Any) -> Any:
+    mask_fields = _resolve_mask_fields()
+    if not mask_fields:
+        return payload
+    try:
+        return _mask_any(payload, mask_fields)
+    except Exception:
+        return payload
+
+
+def _ensure_displayable(payload: Any) -> Any:
+    if isinstance(payload, dict | list | str | int | float | bool) or payload is None:
+        return payload
+
+    if hasattr(payload, "__dict__"):
+        try:
+            return dict(payload)
+        except Exception:
+            try:
+                return dict(payload.__dict__)
+            except Exception:
+                pass
+
+    try:
+        return str(payload)
+    except Exception:
+        return repr(payload)
+
+
+def _render_markdown_output(data: Any) -> None:
+    try:
+        console.print(Markdown(str(data)))
+    except ImportError:
+        click.echo(str(data))
+
+
 def output_result(
     ctx,
     result: Any,
@@ -458,15 +518,10 @@ def output_result(
     success_message: str | None = None,
 ):
     fmt = _get_view(ctx)
-    data = result.to_dict() if hasattr(result, "to_dict") else result
 
-    # Apply recursive secret masking before any rendering
-    mask_fields = _resolve_mask_fields()
-    if mask_fields:
-        try:
-            data = _mask_any(data, mask_fields)
-        except Exception:
-            pass  # Continue with unmasked data if masking fails
+    data = _coerce_result_payload(result)
+    data = _apply_mask_if_configured(data)
+    data = _ensure_displayable(data)
 
     if fmt == "json":
         click.echo(json.dumps(data, indent=2, default=str))
@@ -477,18 +532,20 @@ def output_result(
         return
 
     if fmt == "md":
-        try:
-            console.print(Markdown(str(data)))
-        except ImportError:
-            # Fallback to plain if markdown not available
-            click.echo(str(data))
+        _render_markdown_output(data)
         return
 
     if success_message:
         console.print(Text(f"[green]✅ {success_message}[/green]"))
 
     if panel_title:
-        console.print(Panel(Pretty(data), title=panel_title, border_style="blue"))
+        console.print(
+            AIPPanel(
+                Pretty(data),
+                title=panel_title,
+                border_style="blue",
+            )
+        )
     else:
         console.print(Text(f"[cyan]{title}:[/cyan]"))
         console.print(Pretty(data))
@@ -500,17 +557,7 @@ def output_result(
 # _PICK_THRESHOLD = int(os.getenv("AIP_PICK_THRESHOLD", "5") or "5")
 
 
-def output_list(
-    ctx,
-    items: list[Any],
-    title: str,
-    columns: list[tuple],
-    transform_func=None,
-):
-    """Display a list with fuzzy palette by default on TTY, Rich table as fallback."""
-    fmt = _get_view(ctx)
-
-    # Normalize rows
+def _normalise_rows(items: list[Any], transform_func) -> list[dict[str, Any]]:
     try:
         rows: list[dict[str, Any]] = []
         for item in items:
@@ -524,106 +571,139 @@ def output_list(
                 rows.append(item)
             else:
                 rows.append({"value": item})
+        return rows
     except Exception:
-        rows = []
+        return []
+
 
-    # Mask secrets (apply before any view)
+def _mask_rows_if_configured(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
     mask_fields = _resolve_mask_fields()
-    if mask_fields:
-        try:
-            rows = [_maybe_mask_row(r, mask_fields) for r in rows]
-        except Exception:
-            pass
+    if not mask_fields:
+        return rows
+    try:
+        return [_maybe_mask_row(row, mask_fields) for row in rows]
+    except Exception:
+        return rows
+
+
+def _render_plain_list(
+    rows: list[dict[str, Any]], title: str, columns: list[tuple]
+) -> None:
+    if not rows:
+        click.echo(f"No {title.lower()} found.")
+        return
+    for row in rows:
+        row_str = " | ".join(str(row.get(key, "N/A")) for key, _, _, _ in columns)
+        click.echo(row_str)
+
+
+def _render_markdown_list(
+    rows: list[dict[str, Any]], title: str, columns: list[tuple]
+) -> None:
+    if not rows:
+        click.echo(f"No {title.lower()} found.")
+        return
+    headers = [header for _, header, _, _ in columns]
+    click.echo(f"| {' | '.join(headers)} |")
+    click.echo(f"| {' | '.join('---' for _ in headers)} |")
+    for row in rows:
+        row_str = " | ".join(str(row.get(key, "N/A")) for key, _, _, _ in columns)
+        click.echo(f"| {row_str} |")
+
+
+def _should_sort_rows(rows: list[dict[str, Any]]) -> bool:
+    return (
+        os.getenv("AIP_TABLE_NO_SORT", "0") not in ("1", "true", "on")
+        and rows
+        and isinstance(rows[0], dict)
+        and "name" in rows[0]
+    )
+
+
+def _create_table(columns: list[tuple], title: str):
+    table = AIPTable(title=title, expand=True)
+    for _key, header, style, width in columns:
+        table.add_column(header, style=style, width=width)
+    return table
+
+
+def _build_table_group(
+    rows: list[dict[str, Any]], columns: list[tuple], title: str
+) -> Group:
+    table = _create_table(columns, title)
+    for row in rows:
+        table.add_row(*[str(row.get(key, "N/A")) for key, _, _, _ in columns])
+    footer = Text(f"\n[dim]Total {len(rows)} items[/dim]")
+    return Group(table, footer)
+
+
+def _should_page_output(row_count: int, is_tty: bool) -> bool:
+    pager_env = (os.getenv("AIP_PAGER", "auto") or "auto").lower()
+    if pager_env in ("0", "off", "false"):
+        return False
+    if pager_env in ("1", "on", "true"):
+        return is_tty
+    try:
+        term_h = console.size.height or 24
+        approx_lines = 5 + row_count
+        return is_tty and (approx_lines >= term_h * 0.5)
+    except Exception:
+        return is_tty
+
+
+def output_list(
+    ctx,
+    items: list[Any],
+    title: str,
+    columns: list[tuple],
+    transform_func=None,
+):
+    """Display a list with fuzzy palette by default on TTY, Rich table as fallback."""
+    fmt = _get_view(ctx)
+    rows = _normalise_rows(items, transform_func)
+    rows = _mask_rows_if_configured(rows)
 
-    # 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]
+        data = (
+            rows
+            if rows
+            else [it.to_dict() if hasattr(it, "to_dict") else it for it in items]
+        )
         click.echo(json.dumps(data, indent=2, default=str))
         return
 
-    # Plain view - simple text output
     if fmt == "plain":
-        if not rows:
-            click.echo(f"No {title.lower()} found.")
-            return
-        for row in rows:
-            row_str = " | ".join(str(row.get(key, "N/A")) for key, _, _, _ in columns)
-            click.echo(row_str)
+        _render_plain_list(rows, title, columns)
         return
 
-    # Markdown view - table format
     if fmt == "md":
-        if not rows:
-            click.echo(f"No {title.lower()} found.")
-            return
-        # Create markdown table
-        headers = [header for _, header, _, _ in columns]
-        click.echo(f"| {' | '.join(headers)} |")
-        click.echo(f"| {' | '.join('---' for _ in headers)} |")
-        for row in rows:
-            row_str = " | ".join(str(row.get(key, "N/A")) for key, _, _, _ in columns)
-            click.echo(f"| {row_str} |")
+        _render_markdown_list(rows, title, columns)
         return
 
     if not items:
         console.print(Text(f"[yellow]No {title.lower()} found.[/yellow]"))
         return
 
-    # Sort by name by default (unless disabled)
-    if (
-        os.getenv("AIP_TABLE_NO_SORT", "0") not in ("1", "true", "on")
-        and rows
-        and isinstance(rows[0], dict)
-        and "name" in rows[0]
-    ):
+    if _should_sort_rows(rows):
         try:
             rows = sorted(rows, key=lambda r: str(r.get("name", "")).lower())
         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):
-        picked = _fuzzy_pick(rows, columns, title)
-
+    picked = (
+        _fuzzy_pick(rows, columns, title)
+        if console.is_terminal and os.isatty(1)
+        else None
+    )
     if picked:
-        # Show a focused, single-row table (easy to copy ID/name)
-        table = Table(title=title, box=box.ROUNDED, expand=True)
-        for _key, header, style, width in columns:
-            table.add_column(header, style=style, width=width)
+        table = _create_table(columns, title)
         table.add_row(*[str(picked.get(key, "N/A")) for key, _, _, _ in columns])
-
         console.print(table)
         console.print(Text("\n[dim]Tip: use `aip agents get <ID>` for details[/dim]"))
         return
 
-    # Build full table
-    table = Table(title=title, box=box.ROUNDED, expand=True)
-    for _key, header, style, width in columns:
-        table.add_column(header, style=style, width=width)
-    for row in rows:
-        table.add_row(*[str(row.get(key, "N/A")) for key, _, _, _ in columns])
-
-    footer = Text(f"\n[dim]Total {len(rows)} items[/dim]")
-    content = Group(table, footer)
-
-    # Auto paging when long
-    is_tty = console.is_terminal and os.isatty(1)
-    pager_env = (os.getenv("AIP_PAGER", "auto") or "auto").lower()
-
-    if pager_env in ("0", "off", "false"):
-        should_page = False
-    elif pager_env in ("1", "on", "true"):
-        should_page = is_tty
-    else:
-        try:
-            term_h = console.size.height or 24
-            approx_lines = 5 + len(rows)
-            should_page = is_tty and (approx_lines >= term_h * 0.5)
-        except Exception:
-            should_page = is_tty
-
-    if should_page:
+    content = _build_table_group(rows, columns, title)
+    if _should_page_output(len(rows), console.is_terminal and os.isatty(1)):
         ansi = _render_ansi(content)
         if not _page_with_system_pager(ansi):
             with console.pager(styles=True):
@@ -701,12 +781,12 @@ def coerce_to_row(item, keys: list[str]) -> dict[str, Any]:
 
 
 def build_renderer(
-    ctx,
+    _ctx,
     *,
     save_path,
     theme="dark",
     verbose=False,
-    tty_enabled=True,
+    _tty_enabled=True,
     live=None,
     snapshots=None,
 ):
@@ -755,30 +835,16 @@ def build_renderer(
     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
+def _build_resource_labels(resources: list[Any]) -> tuple[list[str], dict[str, Any]]:
+    """Build unique display labels for resources."""
     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
+
+        # Create display label
         label_parts = []
         if name and name != "Unknown":
             label_parts.append(name)
@@ -792,39 +858,35 @@ def _fuzzy_pick_for_resources(
             while f"{base} #{i}" in by_label:
                 i += 1
             label = f"{base} #{i}"
+
         labels.append(label)
         by_label[label] = resource
 
+    return labels, by_label
+
+
+def _fuzzy_pick_for_resources(
+    resources: list[Any], resource_type: str, _search_term: str
+) -> Any | None:  # pragma: no cover - interactive selection helper
+    """
+    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 _check_fuzzy_pick_requirements():
+        return None
+
+    # Build labels and mapping
+    labels, by_label = _build_resource_labels(resources)
+
     # 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)
+    completer = _FuzzyCompleter(labels)
 
     try:
         answer = prompt(
@@ -836,27 +898,7 @@ def _fuzzy_pick_for_resources(
     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
+    return _perform_fuzzy_search(answer, labels, by_label) if answer else None
 
 
 def resolve_resource(
@@ -945,9 +987,8 @@ def handle_ambiguous_resource(
             f"[yellow]Multiple {resource_type.replace('{', '{{').replace('}', '}}')}s found matching '{ref.replace('{', '{{').replace('}', '}}')}':[/yellow]"
         )
     )
-    table = Table(
+    table = AIPTable(
         title=f"Select {resource_type.replace('{', '{{').replace('}', '}}').title()}",
-        box=box.ROUNDED,
     )
     table.add_column("#", style="dim", width=3)
     table.add_column("ID", style="dim", width=36)