lkr-dev-cli 0.0.38__tar.gz → 0.0.39__tar.gz

lkr_dev_cli-0.0.39/.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+  workflow_dispatch:
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v2
+        with:
+          version: latest
+
+      - name: Install dependencies
+        run: |
+          uv sync --extra all
+
+      - name: Run with pytest
+        run: |
+          uv run pytest tests/ -v
+
+      - name: Run ruff
+        run: |
+          uv run ruff check .
+
+      - name: Run ty
+        run: |
+          uv run ty check
+

lkr_dev_cli-0.0.39/.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+  "[python]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.codeActionsOnSave": {
+      "source.fixAll.ruff": "always",
+      "source.organizeImports.ruff": "always"
+    }
+  },
+  "python.defaultInterpreterPath": "${workspaceFolder}/backend/.venv/bin/python",
+  "ruff.interpreter": ["${workspaceFolder}/backend/.venv/bin/python"],
+  "ty.configurationFile": "./ty.toml",
+  "python.pyrefly.typeCheckingMode": "off",
+  "python.pyrefly.disableLanguageServices": true,
+  "python.pyrefly.disableTypeErrors": true
+}

{lkr_dev_cli-0.0.38 → lkr_dev_cli-0.0.39}/PKG-INFO

@@ -1,38 +1,37 @@
 Metadata-Version: 2.4
 Name: lkr-dev-cli
-Version: 0.0.38
+Version: 0.0.39
 Summary: lkr: a command line interface for looker
 Author: bwebs
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.12
-Requires-Dist: cryptography>=45.0.4
+Requires-Dist: cryptography>=48.0.1
 Requires-Dist: looker-sdk>=25.10.0
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pydash>=8.0.5
-Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: questionary>=2.1.0
-Requires-Dist: requests>=2.32.4
+Requires-Dist: requests>=2.34.2
 Requires-Dist: structlog>=25.4.0
 Requires-Dist: typer>=0.16.0
 Provides-Extra: all
 Requires-Dist: duckdb>=1.3.1; extra == 'all'
-Requires-Dist: fastapi[standard]>=0.115.14; extra == 'all'
-Requires-Dist: mcp[cli]>=1.10.1; extra == 'all'
+Requires-Dist: fastapi[standard]>=0.136.3; extra == 'all'
+Requires-Dist: mcp[cli]>=1.27.2; extra == 'all'
 Requires-Dist: pydantic-monty; extra == 'all'
 Requires-Dist: selenium>=4.34.0; extra == 'all'
 Provides-Extra: codemode
-Requires-Dist: mcp[cli]>=1.10.1; extra == 'codemode'
+Requires-Dist: mcp[cli]>=1.27.2; extra == 'codemode'
 Requires-Dist: pydantic-monty; extra == 'codemode'
 Provides-Extra: mcp
 Requires-Dist: duckdb>=1.3.1; extra == 'mcp'
-Requires-Dist: fastapi[standard]>=0.115.14; extra == 'mcp'
-Requires-Dist: mcp[cli]>=1.10.1; extra == 'mcp'
+Requires-Dist: fastapi[standard]>=0.136.3; extra == 'mcp'
+Requires-Dist: mcp[cli]>=1.27.2; extra == 'mcp'
 Provides-Extra: observability
-Requires-Dist: fastapi[standard]>=0.115.14; extra == 'observability'
+Requires-Dist: fastapi[standard]>=0.136.3; extra == 'observability'
 Requires-Dist: selenium>=4.34.0; extra == 'observability'
 Provides-Extra: tools
-Requires-Dist: fastapi[standard]>=0.115.14; extra == 'tools'
+Requires-Dist: fastapi[standard]>=0.136.3; extra == 'tools'
 Description-Content-Type: text/markdown
 
 # lkr cli

{lkr_dev_cli-0.0.38 → lkr_dev_cli-0.0.39}/lkr/auth/main.py

@@ -45,6 +45,16 @@ def login(
             help="Name of the Looker instance to login or switch to",
         ),
     ] = None,
+    port: Annotated[
+        int | None,
+        typer.Option(
+            "-p",
+            "--port",
+            min=1,
+            max=65535,
+            help="Port to run the local OAuth redirect web server on",
+        ),
+    ] = None,
 ):
     """
     Login to Looker instance using OAuth2 or switch to an existing authenticated instance
@@ -101,10 +111,28 @@ def login(
             origin = urllib.parse.urlunparse(
                 (parsed_url.scheme, parsed_url.netloc, "", "", "", "")
             )
-            use_production = typer.confirm("Use production mode?", default=False)
+            if QUESTIONARY_AVAILABLE:
+                mode = questionary.select(
+                    "Do you want this instance to be used for production or development mode?",
+                    choices=[
+                        questionary.Choice("Development", value=False),
+                        questionary.Choice("Production", value=True),
+                    ],
+                    pointer=">",
+                ).ask()
+                if mode is None:
+                    raise typer.Exit()
+                use_production = mode
+            else:
+                use_production = typer.confirm("Use production mode?", default=False)
+            clean_netloc = (
+                parsed_url.netloc.split(":")[0]
+                .removesuffix(".cloud.looker.com")
+                .removesuffix(".looker.com")
+            )
             instance_name = typer.prompt(
                 "Enter a name for this Looker instance",
-                default=f"{'dev' if not use_production else 'prod'}-{parsed_url.netloc}",
+                default=f"{'prod' if use_production else 'dev'}-{clean_netloc}",
             )
             # Ensure instance_name is str, not None
             assert instance_name is not None, (
@@ -115,13 +143,21 @@ def login(
                 auth.add_auth(instance_name, origin, token, use_production)
 
             oauth = OAuth2PKCE(
-                new_token_callback=auth_callback, use_production=use_production
+                new_token_callback=auth_callback,
+                use_production=use_production,
+                port=port,
             )
             logger.info(f"Opening browser for authentication at {origin + '/auth'}...")
+            logger.info(
+                f"Listening for OAuth callback on http://localhost:{oauth.port}/callback..."
+            )
             login_response = oauth.initiate_login(origin)
 
             if login_response["auth_code"]:
                 logger.info("Successfully received authorization code!")
+                logger.debug(
+                    "Exchanging authorization code for tokens at /api/token..."
+                )
                 try:
                     oauth.auth_code = login_response["auth_code"]
                     token = oauth.exchange_code_for_token()
@@ -136,7 +172,12 @@ def login(
                     )
                     raise typer.Exit(1)
             else:
-                logger.error("Failed to receive authorization code")
+                logger.error(
+                    "Failed to receive authorization code from OAuth callback."
+                )
+                logger.debug(
+                    "Check if the browser redirected correctly or if an error was returned."
+                )
                 raise typer.Exit(1)
             do_switch(instance_name)
 
@@ -199,8 +240,10 @@ def whoami(ctx: typer.Context):
             )
             raise typer.Exit(1)
         user = sdk.me()
+        session_info = sdk.session()
+        
         logger.info(
-            f"Currently authenticated as {user.first_name} {user.last_name} ({user.email}) to {sdk.auth.settings.base_url}"
+            f"Currently authenticated as {user.first_name} {user.last_name} ({user.email}) to {sdk.auth.settings.base_url} in {session_info.workspace_id}"
         )
     except Exception as e:
         if "invalid_grant" in str(e) or "token expired" in str(e):

{lkr_dev_cli-0.0.38 → lkr_dev_cli-0.0.39}/lkr/auth/oauth.py

@@ -3,14 +3,16 @@ import os
 import secrets
 import socket
 import socketserver
+import subprocess
 import threading
 import time
 import urllib.parse
 import webbrowser
-from typing import Optional, TypedDict
+from typing import Optional, TypedDict, cast
 from urllib.parse import parse_qs
 
 from lkr.custom_types import NewTokenCallback
+from lkr.logger import logger
 
 
 def kill_process_on_port(port: int, retries: int = 5, delay: float = 1) -> None:
@@ -25,10 +27,16 @@ def kill_process_on_port(port: int, retries: int = 5, delay: float = 1) -> None:
     except socket.error:
         # Port is in use, try to kill the process
         if os.name == "posix":  # macOS/Linux
-            os.system(f"lsof -ti tcp:{port} | xargs kill -9 2>/dev/null")
+            subprocess.run(
+                f"lsof -ti tcp:{port} | xargs kill -9",
+                shell=True,
+                capture_output=True,
+            )
         elif os.name == "nt":  # Windows
-            os.system(
-                f'for /f "tokens=5" %a in (\'netstat -aon ^| find ":{port}"\') do taskkill /F /PID %a 2>nul'
+            subprocess.run(
+                f'for /f "tokens=5" %a in (\'netstat -aon ^| find ":{port}"\') do taskkill /F /PID %a',
+                shell=True,
+                capture_output=True,
             )
         # After killing, wait for the port to be free
         for _ in range(retries):
@@ -46,24 +54,56 @@ def kill_process_on_port(port: int, retries: int = 5, delay: float = 1) -> None:
 class OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
     def do_GET(self):
         """Handle the callback from OAuth authorization"""
+        parsed_url = urllib.parse.urlparse(self.path)
+        logger.debug(f"OAuthCallbackHandler received GET request for path: {self.path}")
+
+        # Ignore requests that are not the callback (e.g. /favicon.ico)
+        if parsed_url.path != "/callback":
+            logger.debug(f"Ignoring non-callback request: {self.path}")
+            self.send_response(404)
+            self.end_headers()
+            return
+
         self.send_response(200)
         self.send_header("Content-type", "text/html")
         self.end_headers()
 
-        # Parse the authorization code from query parameters
-        query_components = parse_qs(urllib.parse.urlparse(self.path).query)
+        # Parse the authorization code or error from query parameters
+        query_components = parse_qs(parsed_url.query)
+        logger.debug(f"OAuth callback query parameters: {query_components}")
 
         # Store the code in the server instance
+        server = cast(OAuthCallbackServer, self.server)
         if "code" in query_components:
-            self.server.auth_code = query_components["code"][0]  # type: ignore
-
-        # Display a success message to the user
-        self.wfile.write(
-            b"Successfully authenticated to Looker OAuth! You can close this window."
-        )
-
-        # Shutdown the server
-        threading.Thread(target=self.server.shutdown).start()
+            server.auth_code = query_components["code"][0]
+            logger.debug(
+                f"Authorization code received successfully: {server.auth_code[:5]}..."
+            )
+            self.wfile.write(
+                b"Successfully authenticated to Looker OAuth! You can close this window."
+            )
+            # Shutdown the server
+            threading.Thread(target=server.shutdown).start()
+        elif "error" in query_components:
+            error = query_components["error"][0]
+            error_description = query_components.get("error_description", [""])[0]
+            logger.error(
+                f"Looker OAuth returned error: {error} - {error_description}"
+            )
+            self.wfile.write(
+                f"OAuth Authentication Failed: {error} - {error_description}. You can close this window.".encode(
+                    "utf-8"
+                )
+            )
+            threading.Thread(target=server.shutdown).start()
+        else:
+            logger.warning(
+                f"Callback received without 'code' or 'error' query parameters: {self.path}"
+            )
+            self.wfile.write(
+                b"OAuth Authentication Failed: Invalid callback request. You can close this window."
+            )
+            threading.Thread(target=server.shutdown).start()
 
     def log_message(self, format, *args):
         """Suppress logging of requests"""
@@ -71,6 +111,8 @@ class OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
 
 
 class OAuthCallbackServer(socketserver.TCPServer):
+    allow_reuse_address = True
+
     def __init__(self, server_address):
         super().__init__(server_address, OAuthCallbackHandler)
         self.auth_code: str | None = None
@@ -82,7 +124,12 @@ class LoginResponse(TypedDict):
 
 
 class OAuth2PKCE:
-    def __init__(self, new_token_callback: NewTokenCallback, use_production: bool):
+    def __init__(
+        self,
+        new_token_callback: NewTokenCallback,
+        use_production: bool,
+        port: int | None = None,
+    ):
         from lkr.auth_service import DbOAuthSession
 
         self.auth_code: Optional[str] = None
@@ -91,7 +138,7 @@ class OAuth2PKCE:
         self.auth_session: DbOAuthSession | None = None
         self.server_thread: threading.Thread | None = None
         self.server: OAuthCallbackServer | None = None
-        self.port: int = 8000
+        self.port: int = port if port is not None else 8000
         self.use_production: bool = use_production
 
     def cleanup(self):
@@ -152,11 +199,15 @@ class OAuth2PKCE:
 
         # Construct and open the OAuth URL
         self.auth_session = get_auth_session(
-            base_url, self.new_token_callback, use_production=self.use_production
+            base_url,
+            self.new_token_callback,
+            use_production=self.use_production,
+            port=self.port,
         )
         oauth_url = self.auth_session.create_auth_code_request_url(
             "cors_api", self.state
         )
+        logger.debug(f"Constructed OAuth URL: {oauth_url}")
 
         webbrowser.open(oauth_url)
 

{lkr_dev_cli-0.0.38 → lkr_dev_cli-0.0.39}/lkr/auth_service.py

@@ -3,23 +3,22 @@ import os
 import sqlite3
 import types
 from datetime import datetime, timedelta, timezone
-from typing import List, Self, Tuple, Union, TYPE_CHECKING
+from typing import List, Self, Tuple, Union
 
 import requests
-if TYPE_CHECKING:
-    import typer
+import typer
 from looker_sdk.rtl import serialize
 from looker_sdk.rtl.api_settings import ApiSettings, SettingsConfig
 from looker_sdk.rtl.auth_session import AuthSession, CryptoHash, OAuthSession
 from looker_sdk.rtl.auth_token import AccessToken, AuthToken
 from looker_sdk.rtl.requests_transport import RequestsTransport
 from looker_sdk.rtl.transport import LOOKER_API_ID, HttpMethod
-from looker_sdk.sdk.api40.methods import Looker40SDK
+from lkr.extended_sdk_methods import ExtendedLooker40SDK as Looker40SDK
 from pydantic import BaseModel, Field, computed_field
 from pydash import get
 
 from lkr.classes import LkrCtxObj, LookerApiKey
-from lkr.constants import LOOKER_API_VERSION, OAUTH_CLIENT_ID, OAUTH_REDIRECT_URI
+from lkr.constants import LOOKER_API_VERSION, OAUTH_CLIENT_ID
 from lkr.custom_types import NewTokenCallback
 from lkr.logger import logger
 
@@ -30,8 +29,9 @@ def is_auth_expired(e: Exception) -> bool:
     return "invalid_grant" in str(e) or "token expired" in str(e)
 
 
-
-def get_auth(ctx: Union["typer.Context", LkrCtxObj]) -> Union["SqlLiteAuth", "ApiKeyAuth"]:
+def get_auth(
+    ctx: Union["typer.Context", LkrCtxObj],
+) -> Union["SqlLiteAuth", "ApiKeyAuth"]:
     if isinstance(ctx, LkrCtxObj):
         lkr_ctx = ctx
     else:
@@ -61,8 +61,9 @@ class ApiKeyApiSettings(ApiSettings):
 
 
 class OAuthApiSettings(ApiSettings):
-    def __init__(self, base_url: str):
+    def __init__(self, base_url: str, port: int = 8000):
         self.base_url = base_url
+        self.port = port
         super().__init__()
         self.agent_tag = "lkr-cli-oauth"
 
@@ -72,7 +73,7 @@ class OAuthApiSettings(ApiSettings):
             looker_url=self.base_url,
             client_id=OAUTH_CLIENT_ID,
             client_secret="",  # PKCE doesn't need client secret
-            redirect_uri=OAUTH_REDIRECT_URI,
+            redirect_uri=f"http://localhost:{self.port}/callback",
         )
 
 
@@ -127,6 +128,12 @@ class DbOAuthSession(OAuthSession):
 
     def redeem_auth_code(self, *args, **kwargs):
         super().redeem_auth_code(*args, **kwargs)
+        if not self.use_production:
+            try:
+                self._switch_to_dev_mode()
+            except Exception as e:
+                logger.error(f"Failed to switch to development mode: {e}")
+                raise typer.Exit(1)
         self.new_token_callback(self.token)
 
     def _switch_to_dev_mode(self):
@@ -155,8 +162,9 @@ def get_auth_session(
     *,
     use_production: bool,
     access_token: AccessToken | None = None,
+    port: int = 8000,
 ) -> DbOAuthSession:
-    settings = OAuthApiSettings(base_url)
+    settings = OAuthApiSettings(base_url, port=port)
     transport = MonkeyPatchTransport.configure(settings)
     auth = DbOAuthSession(
         settings=settings,
@@ -183,7 +191,7 @@ def init_api_key_sdk(api_key: LookerApiKey, use_production: bool) -> Looker40SDK
         auth=ApiKeyAuthSession(
             settings,
             transport,
-            serialize.deserialize40,  # type: ignore
+            serialize.deserialize40,
             LOOKER_API_VERSION,
             use_production=use_production,
         ),
@@ -208,7 +216,9 @@ def monkey_patch_prepare_request(session: requests.Session):
             x.headers.pop(LOOKER_API_ID)
         return x
 
-    session.prepare_request = types.MethodType(prepare_request, session)
+    setattr(
+        session, "prepare_request", types.MethodType(prepare_request, session)
+    )
 
 
 class MonkeyPatchTransport(RequestsTransport):
@@ -223,9 +233,10 @@ def init_oauth_sdk(
     *,
     access_token: AccessToken | None = None,
     use_production: bool = False,
+    port: int = 8000,
 ) -> Looker40SDK:
     """Default dependency configuration"""
-    settings = OAuthApiSettings(base_url)
+    settings = OAuthApiSettings(base_url, port=port)
     settings.is_configured()
     transport = MonkeyPatchTransport.configure(settings)
 
@@ -234,6 +245,7 @@ def init_oauth_sdk(
         new_token_callback,
         access_token=access_token,
         use_production=use_production,
+        port=port,
     )
     return Looker40SDK(
         auth=auth,
@@ -357,11 +369,12 @@ class CurrentAuth(BaseModel):
         ).isoformat()
         if self.from_db and new_token:
             connection.execute(
-                "UPDATE auth SET access_token = ?, token_type = ?, expires_at = ? WHERE current_instance = 1",
+                "UPDATE auth SET access_token = ?, token_type = ?, expires_at = ? WHERE instance_name = ?",
                 (
                     new_token.access_token,
                     new_token.token_type,
                     expires_at,
+                    self.instance_name,
                 ),
             )
         else:
@@ -385,6 +398,7 @@ class CurrentAuth(BaseModel):
 
 class SqlLiteAuth:
     def __init__(self, ctx: LkrCtxObj, db_path: str = "~/.lkr/auth.db"):
+        self.ctx = ctx
         self.db_path = os.path.expanduser(db_path)
         # Ensure the directory exists
         db_dir = os.path.dirname(self.db_path)
@@ -442,6 +456,16 @@ class SqlLiteAuth:
         self.conn.commit()
 
     def _get_current_auth(self) -> CurrentAuth | None:
+        if self.ctx.oauth_account:
+            cursor = self.conn.execute(
+                "SELECT instance_name, access_token, refresh_token, refresh_expires_at, token_type, expires_at, base_url, use_production FROM auth WHERE instance_name = ?",
+                (self.ctx.oauth_account,),
+            )
+            row = cursor.fetchone()
+            if row:
+                return CurrentAuth.from_db_row(row)
+            logger.error("couldnt find oauth account in db, run lkr auth login")
+            raise typer.Exit(1)
         cursor = self.conn.execute(
             "SELECT instance_name, access_token, refresh_token, refresh_expires_at, token_type, expires_at, base_url, use_production FROM auth WHERE current_instance = 1"
         )
@@ -474,16 +498,20 @@ class SqlLiteAuth:
                 current_auth.base_url,
                 new_token_callback=refresh_current_token,
                 access_token=current_auth.to_access_token(),
+                use_production=current_auth.use_production,
             )
             if prompt_refresh_invalid_token:
                 import sys
+
                 try:
                     sdk.auth.authenticate({})
                 except Exception as e:
                     if is_auth_expired(e):
                         if sys.stdin.isatty():
                             self._cli_confirm_refresh_token(current_auth, quiet=False)
-                            return self.get_current_sdk(prompt_refresh_invalid_token=False)
+                            return self.get_current_sdk(
+                                prompt_refresh_invalid_token=False
+                            )
                     raise e
 
             return sdk

{lkr_dev_cli-0.0.38 → lkr_dev_cli-0.0.39}/lkr/classes.py

@@ -25,6 +25,7 @@ class LkrCtxObj(BaseModel):
     api_key: LookerApiKey | None
     force_oauth: bool = False
     use_production: bool = True
+    oauth_account: str | None = None
 
     @property
     def use_sdk(self) -> Literal["oauth", "api_key"]:

{lkr_dev_cli-0.0.38 → lkr_dev_cli-0.0.39}/lkr/codemode/help.py

@@ -1,6 +1,5 @@
 import re
 import inspect
-import fnmatch
 import json
 import os
 from lkr.codemode.constant import EXCLUDED_FUNCS
@@ -126,14 +125,61 @@ def _get_matches(query: str, external_funcs: dict, sdk) -> list:
             
     return matches
 
+def _get_type_matches(query: str) -> list:
+    escaped_query = re.escape(query).replace(r'\*', '.*').replace(r'\?', '.')
+    try:
+        pattern = re.compile(escaped_query, re.IGNORECASE)
+    except re.error:
+        pattern = re.compile(re.escape(query), re.IGNORECASE)
+
+    try:
+        from lkr.codemode.type import _get_swagger_data, _get_ext_definitions
+        swagger = _get_swagger_data()
+        definitions = dict(swagger.get('definitions', {}))
+        definitions.update(_get_ext_definitions())
+    except Exception:
+        return []
+
+    matches = []
+    for type_name, def_obj in definitions.items():
+        if not isinstance(def_obj, dict):
+            continue
+        hit_in_name = bool(pattern.search(type_name))
+        
+        matching_props = []
+        matching_desc = []
+        
+        properties = def_obj.get('properties', {})
+        if isinstance(properties, dict):
+            for prop_name, prop_val in properties.items():
+                if not isinstance(prop_val, dict):
+                    continue
+                if pattern.search(prop_name):
+                    matching_props.append(prop_name)
+                desc = prop_val.get('description', '')
+                if desc and pattern.search(desc):
+                    matching_desc.append(f"{prop_name}: {desc.strip().splitlines()[0]}")
+                
+        if hit_in_name or matching_props or matching_desc:
+            matches.append({
+                'name': type_name,
+                'hit_in_name': hit_in_name,
+                'matching_props': matching_props,
+                'matching_desc': matching_desc
+            })
+    return sorted(matches, key=lambda x: x['name'])
+
+
 def search_help(query: str, external_funcs: dict, sdk) -> str:
     """Search for functions and return a summary string with snippets."""
-    matches = _get_matches(query, external_funcs, sdk)
-    if not matches:
+    func_matches = _get_matches(query, external_funcs, sdk)
+    type_matches = _get_type_matches(query)
+    
+    if not func_matches and not type_matches:
         return f"No matches found for '{query}'."
         
     lines = []
-    for m in matches:
+    for m in func_matches:
         hit_info = []
         if m['hit_in_name']:
             hit_info.append("Name match")
@@ -144,22 +190,49 @@ def search_help(query: str, external_funcs: dict, sdk) -> str:
         if m['output_fields']:
             hit_info.append(f"Output field match: {', '.join(m['output_fields'][:2])}")
             
-        lines.append(f"- {m['name']} ({' | '.join(hit_info)})")
+        lines.append(f"- Function: {m['name']} ({' | '.join(hit_info)})")
+        
+    for m in type_matches:
+        hit_info = []
+        if m['hit_in_name']:
+            hit_info.append("Name match")
+        if m['matching_props']:
+            hit_info.append(f"Property match: {', '.join(m['matching_props'][:2])}")
+        if m['matching_desc']:
+            hit_info.append(f"Comment hit: \"{m['matching_desc'][0]}\"")
+            
+        lines.append(f"- Type: {m['name']} ({' | '.join(hit_info)})")
         
     return f"Matches found for '{query}':\n" + "\n".join(lines)
 
 def search_with_lookups(query: str, external_funcs: dict, sdk) -> list:
     """Search for functions and return the array of lookups for matches."""
-    matches = _get_matches(query, external_funcs, sdk)
+    func_matches = _get_matches(query, external_funcs, sdk)
+    type_matches = _get_type_matches(query)
+    
     results = []
-    for m in matches:
+    for m in func_matches:
         results.append(lookup_function(m['name'], external_funcs, sdk))
+    for m in type_matches:
+        try:
+            from lkr.codemode.type import lookup_type
+            results.append(lookup_type(m['name']))
+        except Exception:
+            pass
     return results
 
 def lookup_function(name: str, external_funcs: dict, sdk) -> str:
-    """Look up the exact name of a function and return its docstring, inputs, and outputs."""
+    """Look up the exact name of a function or type and return its docstring, inputs, and outputs."""
     if name not in external_funcs:
-        return f"Function '{name}' not found."
+        # Check if it's a type name
+        try:
+            from lkr.codemode.type import lookup_type
+            res = lookup_type(name)
+            if not res.startswith("Type '"):
+                return res
+        except Exception:
+            pass
+        return f"Function or type '{name}' not found."
         
     if not hasattr(sdk, name):
         return f"{name} is a built-in helper function."