lkr-dev-cli 0.0.36__tar.gz → 0.0.37__tar.gz

{lkr_dev_cli-0.0.36 → lkr_dev_cli-0.0.37}/Makefile

@@ -1,4 +1,4 @@
-.PHONY: docs test-deps codemode-test codemode-test2 codemode-start
+.PHONY: docs test-deps codemode-test codemode-start
 
 docs:
 	uv run typer lkr/main.py utils docs --output lkr.md
@@ -7,11 +7,11 @@ test-deps:
 	python tests/test_dependency_resolution.py 
 
 codemode-test:
-	uv run python tests/test_codemode.py
+	uv run pytest tests/test_codemode.py
 
-codemode-test2:
-	uv run python tests/test_codemode2.py
 
+download-swagger:
+	uv run python lkr/codemode/download_swagger.py
 
 codemode-start:
 	@echo "Add this to your mcpServers config:"

{lkr_dev_cli-0.0.36 → lkr_dev_cli-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lkr-dev-cli
-Version: 0.0.36
+Version: 0.0.37
 Summary: lkr: a command line interface for looker
 Author: bwebs
 License-Expression: MIT
@@ -10,6 +10,7 @@ Requires-Dist: cryptography>=45.0.4
 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: structlog>=25.4.0

lkr_dev_cli-0.0.37/lkr/codemode/constant.py

@@ -0,0 +1 @@
+EXCLUDED_FUNCS = ['dir', 'help', 'examples', 'readme', 'lookup', 'sdk', 'search_with_lookups', 'lookup_type']

lkr_dev_cli-0.0.37/lkr/codemode/download_swagger.py

@@ -0,0 +1,49 @@
+import os
+import requests
+import json
+import sys
+from dotenv import load_dotenv
+
+
+def download_swagger():
+    base_url = os.environ.get("LOOKERSDK_BASE_URL")
+    
+    if not base_url:
+        # Try to load from .env in project root
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        env_path = os.path.join(current_dir, "..", "..", ".env")
+        if os.path.exists(env_path):
+            print(f"Loading environment from {env_path}")
+            load_dotenv(env_path)
+            base_url = os.environ.get("LOOKERSDK_BASE_URL")
+                        
+    if not base_url:
+        print("Error: LOOKERSDK_BASE_URL environment variable not set.", file=sys.stderr)
+        sys.exit(1)
+    
+    url = f"{base_url.rstrip('/')}/api/4.0/swagger.json"
+    output_dir = os.path.dirname(os.path.abspath(__file__))
+    output_path = os.path.join(output_dir, "swagger.json")
+    
+    print(f"Downloading swagger.json from {url} ...")
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        
+        # Verify it's JSON
+        try:
+            swagger_data = response.json()
+        except ValueError:
+            print("Error: Response is not valid JSON.", file=sys.stderr)
+            sys.exit(1)
+            
+        with open(output_path, "w") as f:
+            json.dump(swagger_data, f, indent=2)
+            
+        print(f"Saved swagger.json to {output_path}")
+    except requests.RequestException as e:
+        print(f"Error downloading swagger.json: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    download_swagger()

lkr_dev_cli-0.0.37/lkr/codemode/examples.py

@@ -0,0 +1,24 @@
+EXAMPLES = [
+    [
+        "Find all dashboard-related methods",
+        "return [m for m in dir() if 'dashboard' in m.lower()]"
+    ],
+    [
+        "Get the description of a specific method",
+        "return help('search_dashboards')"
+    ],
+    [
+        "List personal dashboards",
+        """def get_all_items(folder_id):
+    f = folder(folder_id)
+    items = {"dashboards": f.get("dashboards", []), "looks": f.get("looks", [])}
+    for child in folder_children(folder_id):
+        child_items = get_all_items(child["id"])
+        items["dashboards"].extend(child_items["dashboards"])
+        items["looks"].extend(child_items["looks"])
+    return items
+
+me_data = me()
+return get_all_items(me_data["personal_folder_id"])"""
+    ]
+]

lkr_dev_cli-0.0.37/lkr/codemode/help.py

@@ -0,0 +1,210 @@
+import re
+import inspect
+import fnmatch
+import json
+import os
+from lkr.codemode.constant import EXCLUDED_FUNCS
+
+_operation_map = None
+
+def _get_operation_map():
+    global _operation_map
+    if _operation_map is not None:
+        return _operation_map
+        
+    _operation_map = {}
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    swagger_path = os.path.join(current_dir, 'swagger.json')
+    
+    if not os.path.exists(swagger_path):
+        return _operation_map
+        
+    try:
+        with open(swagger_path, 'r') as f:
+            swagger = json.load(f)
+            paths = swagger.get('paths', {})
+            for path, path_item in paths.items():
+                for method, op in path_item.items():
+                    if isinstance(op, dict) and 'operationId' in op:
+                        op_id = op['operationId']
+                        summary = op.get('summary', '')
+                        description = op.get('description', '')
+                        if description.startswith('###'):
+                            description = description.lstrip('#').strip()
+                        _operation_map[op_id] = {
+                            'summary': summary,
+                            'description': description
+                        }
+    except (OSError, json.JSONDecodeError):
+        pass
+        
+    return _operation_map
+
+def _get_enhanced_doc(name: str, method) -> str:
+    doc = method.__doc__ or ""
+    op_map = _get_operation_map()
+    if name in op_map:
+        op_info = op_map[name]
+        summary = op_info['summary']
+        description = op_info['description']
+        
+        parts = []
+        if summary:
+            parts.append(summary)
+        if description:
+            parts.append(description)
+            
+        if parts:
+            return "\n".join(parts)
+            
+    return doc
+
+
+def _get_matches(query: str, external_funcs: dict, sdk) -> list:
+    """Helper to get matching functions with hit details."""
+    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)
+
+    matches = []
+    for name in external_funcs:
+        if name in EXCLUDED_FUNCS:
+            continue
+            
+        doc = ""
+        method = None
+        if hasattr(sdk, name):
+            method = getattr(sdk, name)
+            doc = _get_enhanced_doc(name, method)
+            
+        hit_in_name = bool(pattern.search(name))
+        
+        # Search in docstring lines
+        matching_lines = []
+        if doc:
+            for line in doc.split('\n'):
+                if pattern.search(line):
+                    matching_lines.append(line.strip())
+                    
+        # Search in parameters (Inputs)
+        hit_in_params = False
+        if method:
+            try:
+                sig = inspect.signature(method)
+                params = list(sig.parameters.keys())
+                if any(pattern.search(p) for p in params):
+                    hit_in_params = True
+            except Exception:
+                pass
+                
+        # Search in return type fields (Outputs)
+        hit_in_output = False
+        output_fields = []
+        if method:
+            try:
+                sig = inspect.signature(method)
+                return_type = sig.return_annotation
+                if return_type and hasattr(return_type, '__annotations__'):
+                    fields = list(return_type.__annotations__.keys())
+                    matching_fields = [f for f in fields if pattern.search(f)]
+                    if matching_fields:
+                        hit_in_output = True
+                        output_fields = matching_fields
+            except Exception:
+                pass
+                
+        if hit_in_name or matching_lines or hit_in_params or hit_in_output:
+            matches.append({
+                'name': name,
+                'hit_in_name': hit_in_name,
+                'matching_lines': matching_lines,
+                'hit_in_params': hit_in_params,
+                'output_fields': output_fields
+            })
+            
+    return matches
+
+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:
+        return f"No matches found for '{query}'."
+        
+    lines = []
+    for m in matches:
+        hit_info = []
+        if m['hit_in_name']:
+            hit_info.append("Name match")
+        if m['matching_lines']:
+            hit_info.append(f"Doc hit: \"{m['matching_lines'][0]}\"")
+        if m['hit_in_params']:
+            hit_info.append("Input param match")
+        if m['output_fields']:
+            hit_info.append(f"Output field match: {', '.join(m['output_fields'][:2])}")
+            
+        lines.append(f"- {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)
+    results = []
+    for m in matches:
+        results.append(lookup_function(m['name'], external_funcs, sdk))
+    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."""
+    if name not in external_funcs:
+        return f"Function '{name}' not found."
+        
+    if not hasattr(sdk, name):
+        return f"{name} is a built-in helper function."
+        
+    method = getattr(sdk, name)
+    doc = _get_enhanced_doc(name, method) or "No docstring available."
+    
+    def _get_type_str(t):
+        if t == inspect._empty:
+            return "Any"
+        if hasattr(t, '__name__'):
+            return t.__name__
+        return str(t)
+
+    try:
+        sig = inspect.signature(method)
+        
+        # Inputs
+        inputs = []
+        for param_name, param in sig.parameters.items():
+            inputs.append(f"- {param_name}: {_get_type_str(param.annotation)}")
+        inputs_str = "\n".join(inputs) if inputs else "None"
+        
+        # Outputs
+        return_type = sig.return_annotation
+        outputs_str = f"Return Type: {_get_type_str(return_type)}"
+        
+        if return_type and hasattr(return_type, '__annotations__'):
+            fields = []
+            for field_name, field_type in return_type.__annotations__.items():
+                fields.append(f"  - {field_name}: {_get_type_str(field_type)}")
+            if fields:
+                outputs_str += "\nFields:\n" + "\n".join(fields)
+                
+        return f"""
+Function: {name}
+
+Docstring:
+{doc}
+
+Inputs:
+{inputs_str}
+
+Outputs:
+{outputs_str}
+"""
+    except Exception as e:
+        return f"Function: {name}\n\nDocstring:\n{doc}\n\n(Could not inspect signature: {e})"

{lkr_dev_cli-0.0.36 → lkr_dev_cli-0.0.37}/lkr/codemode/main.py

@@ -10,6 +10,11 @@ from mcp.server.fastmcp import FastMCP
 
 from lkr.auth_service import get_auth, is_auth_expired
 from lkr.classes import LkrCtxObj
+from lkr.codemode.examples import EXAMPLES
+from lkr.codemode.help import search_help, lookup_function, search_with_lookups
+from lkr.codemode.readme import get_readme
+from lkr.codemode.constant import EXCLUDED_FUNCS
+from lkr.codemode.type import lookup_type
 from lkr.logger import logger
 
 __all__ = ["group"]
@@ -58,20 +63,26 @@ def to_primitive(obj):
 
 
 @mcp.tool()
-def run_python_code(code: str) -> str:
+def run_python_code(code: str, dev_mode: bool = False) -> str:
     """
     Execute Python code safely with access to all Looker SDK methods as global functions.
     Capture the result. 
     
     AGENT HINTS:
-    - Use `dir()` and `help('method_name')` to discover available SDK methods.
+    - CRITICAL: Call `readme()` first if you haven't already to see full instructions and examples.
+    - Use `dir()`, `help('pattern')`, `lookup('method_name')`, `lookup_type('TypeName')`, and `examples()` to discover available SDK methods, types, and patterns.
     - Do not instantiate an SDK; use global functions directly (e.g. `me()`).
+    - You can also use `sdk.method_name()` (e.g. `sdk.me()`) if preferred.
     - Returned Looker models are primitive dictionaries (use `obj["id"]`, not `obj.id`).
     - Return your output (avoid using print() as it may pollute the stdio stream).
     - Recursion: Use `folder_children(id)` to traverse nested folders.
+    - Dev Mode: Set `dev_mode=True` to ensure you are in development mode before running code.
     """
     try:
         ctx = LkrCtxObj(force_oauth=False)
+
+        if dev_mode:
+            ctx.use_production = False
         sdk = get_mcp_sdk(ctx)
         
         external_funcs = {}
@@ -88,13 +99,21 @@ def run_python_code(code: str) -> str:
         # Provide helper functions for the LLM to explore the SDK
         external_funcs['dir'] = lambda: list(external_funcs.keys())
         
-        def _help(name: str) -> str:
-            if name in external_funcs:
-                if hasattr(sdk, name):
-                    return getattr(sdk, name).__doc__ or "No docstring available."
-                return f"{name} is a built-in helper function."
-            return f"Function '{name}' not found."
-        external_funcs['help'] = _help
+        external_funcs['help'] = lambda query: search_help(query, external_funcs, sdk)
+        external_funcs['lookup'] = lambda name: lookup_function(name, external_funcs, sdk)
+        external_funcs['search_with_lookups'] = lambda query: search_with_lookups(query, external_funcs, sdk)
+        external_funcs['lookup_type'] = lookup_type
+
+        external_funcs['examples'] = lambda: EXAMPLES
+        external_funcs['readme'] = get_readme
+
+        # Add sdk object to support sdk.method_name
+        class SDK:
+            pass
+        for name, func in external_funcs.items():
+            if name not in EXCLUDED_FUNCS:
+                setattr(SDK, name, staticmethod(func))
+        external_funcs['sdk'] = SDK
 
         m = pydantic_monty.Monty(code)
         
@@ -129,64 +148,7 @@ def run_python_code(code: str) -> str:
         return f"Error: {str(e)}"
 
 
-@mcp.resource("looker://agent-hints")
-def get_agent_hints() -> str:
-    """Crucial hints and rules for AI agents writing Python for the Looker SDK."""
-    return """
-1. **Global Functions**: All Looker SDK methods are global. Use `me()`, not `sdk.me()`.
-2. **Dict Access**: Return values are dictionaries, not objects. Use `user["id"]`, not `user.id`.
-3. **Discovery**: Use `dir()` and `help('method')` to explore the SDK.
-4. **No Imports**: Do not `import looker_sdk`.
-5. **Output**: Return your results instead of using `print()`.
-6. **Efficiency**: Always use the `fields` parameter (e.g., `all_dashboards(fields="id,title")`) when listing many objects to prevent timeouts.
-7. **Nested Folders**: Use `folder_children(id)` to get sub-folders.
-"""
-
-
-@mcp.prompt("explore_looker_sdk")
-def explore_looker_sdk() -> str:
-    """Provide examples for how to explore the Looker SDK in code mode."""
-    return '''
-To explore the Looker SDK, you can use the injected `dir()` and `help()` helpers.
-Do not use print() as it may corrupt the MCP output stream; always return the result.
-
-Example 1: Find all dashboard-related methods
-```python
-return [m for m in dir() if 'dashboard' in m.lower()]
-```
-
-Example 2: Get the description of a specific method
-```python
-return help('search_dashboards')
-```
-'''
-
-
-@mcp.prompt("list_personal_dashboards")
-def list_personal_dashboards() -> str:
-    """Provide an example of how to recursively list dashboards in a user's personal folder."""
-    return '''
-Here is a robust example of how to traverse the folder hierarchy using the Looker SDK in code mode:
-
-```python
-def get_all_items(folder_id):
-    f = folder(folder_id)
-    items = {
-        "dashboards": f.get("dashboards", []),
-        "looks": f.get("looks", [])
-    }
-    
-    for child in folder_children(folder_id):
-        child_items = get_all_items(child["id"])
-        items["dashboards"].extend(child_items["dashboards"])
-        items["looks"].extend(child_items["looks"])
-        
-    return items
 
-me_data = me()
-return get_all_items(me_data["personal_folder_id"])
-```
-'''
 
 
 @group.command(name="run")

lkr_dev_cli-0.0.37/lkr/codemode/readme.py

@@ -0,0 +1,58 @@
+def get_readme() -> str:
+    return """
+Looker Code Mode - Instructions & Examples
+
+IMPORTANT: If you have not already run this function, read these instructions carefully before writing any code.
+
+RULES & HINTS:
+1. **SDK Access**: All Looker SDK methods are available as global functions (e.g., `me()`) or via the `sdk` object (e.g., `sdk.me()`).
+2. **Dict Access**: Return values are dictionaries, not objects. Use `user["id"]`, not `user.id`.
+3. **Discovery**: Use `dir()`, `help('pattern')`, `lookup('method_name')`, `lookup_type('TypeName')`, and `examples()` to explore the SDK.
+4. **No Imports**: Do not `import looker_sdk`.
+5. **Output**: Return your results instead of using `print()`.
+6. **Efficiency**: Always use the `fields` parameter (e.g., `all_dashboards(fields="id,title")`) when listing many objects to prevent timeouts.
+7. **Nested Folders**: Use `folder_children(id)` to get sub-folders.
+8. **Search with Lookups**: If `help('pattern')` returns too many results and you want to see full details for all of them at once, use `search_with_lookups('pattern')`.
+
+EXAMPLES:
+
+Example 1: Find all dashboard-related methods (wildcard search)
+```python
+return help('dashboard')
+```
+
+Example 2: Get the description of a specific method
+```python
+return lookup('search_dashboards')
+```
+
+Example 3: Lookup a type definition
+```python
+return lookup_type('User')
+```
+
+Example 4: Search and return full details for all matches
+```python
+return search_with_lookups('board_item')
+```
+
+Example 5: List personal dashboards (Recursive traversal)
+```python
+def get_all_items(folder_id):
+    f = folder(folder_id)
+    items = {
+        "dashboards": f.get("dashboards", []),
+        "looks": f.get("looks", [])
+    }
+    
+    for child in folder_children(folder_id):
+        child_items = get_all_items(child["id"])
+        items["dashboards"].extend(child_items["dashboards"])
+        items["looks"].extend(child_items["looks"])
+        
+    return items
+
+me_data = me()
+return get_all_items(me_data["personal_folder_id"])
+```
+"""