minitap-mcp 0.4.2__tar.gz → 0.5.0__tar.gz

{minitap_mcp-0.4.2 → minitap_mcp-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: minitap-mcp
-Version: 0.4.2
+Version: 0.5.0
 Summary: Model Context Protocol server for controlling Android & iOS devices with natural language
 Author: Pierre-Louis Favreau, Jean-Pierre Lo, Clément Guiguet
 Requires-Dist: fastmcp>=2.12.4
@@ -84,11 +84,18 @@ minitap-mcp --server
 
 CLI flags always override environment variables when both are present.
 
-By default, the server will bind to `0.0.0.0:8000`. Configure via environment variables:
+By default, the server will bind to `0.0.0.0:8000`. You can customize the port:
 
 ```bash
+# Using CLI argument
+minitap-mcp --server --port 9000
+
+# Or using environment variable
+export MCP_SERVER_PORT="9000"
+minitap-mcp --server
+
+# You can also customize the host
 export MCP_SERVER_HOST="0.0.0.0"
-export MCP_SERVER_PORT="8000"
 ```
 
 ## IDE Integration
@@ -120,41 +127,122 @@ export MCP_SERVER_PORT="8000"
 ```
 
 
-## Available Tools
+## Available Resources & Tools
+
+Once connected, your AI assistant can use these resources and tools:
+
+### Resource: `data://devices`
+
+Lists all connected mobile devices (Android and iOS).
 
-Once connected, your AI assistant can use these tools:
+**Returns:** Array of device information objects with:
 
-### `execute_mobile_command`
-Execute natural language commands on your mobile device using the Minitap SDK. This tool allows you to control your Android or iOS device using natural language.
+- `device_id`: Device serial (Android) or UDID (iOS)
+- `platform`: `"android"` or `"ios"`
+- `name`: Device name
+- `state`: Device state (`"connected"` or `"Booted"`)
+
+### Tool: `analyze_screen`
+
+Captures a screenshot from a mobile device and analyzes it using a vision language model.
 
 **Parameters:**
-- `goal` (required): High-level goal describing the action to perform
-- `output_description` (optional): Natural language description of the desired output format. Results are returned as structured JSON (e.g., "An array with sender and subject for each email")
-- `profile` (optional): Profile name to use (defaults to "default")
 
-**Examples:**
+- `prompt` (required): Analysis prompt describing what information to extract
+- `device_id` (optional): Specific device ID to target. If not provided, uses the first available device.
+
+**Returns:** AI-generated analysis of the screenshot based on the prompt.
+
+**Example:**
+
 ```
-"Open the settings app and tell me the battery level"
-"Find the first 3 unread emails in Gmail"
-"Open Google Maps and search for the nearest coffee shop"
-"Take a screenshot and save it"
+Prompt: "What app is currently open? List all visible UI elements."
 ```
 
-### `analyze_screen`
-Capture and analyze what's currently shown on the mobile device screen using a vision-capable LLM. Useful for understanding UI elements, extracting text, or identifying specific features.
+The tool will:
+
+1. Find the specified device (or first available)
+2. Capture a screenshot
+3. Analyze it with the vision model
+4. Return the analysis
+
+### Tool: `execute_mobile_command`
+
+Execute natural language commands on your mobile device using the mobile-use SDK. This tool allows you to control your Android or iOS device with simple instructions.
 
 **Parameters:**
-- `prompt` (required): Analysis prompt describing what information to extract
-- `device_id` (optional): Specific device ID to target
+
+- `goal` (required): Natural language command to execute on the device
+- `output_description` (optional): Description of the expected output format (e.g., "A JSON list of objects with sender and subject keys")
+- `profile` (optional): Name of the profile to use for this task. Defaults to 'default'
+
+**Returns:** Execution result with status, output, and any extracted data.
 
 **Examples:**
-```js
-"What app is currently open?"
-"Read the text messages visible on screen"
-"List all buttons and their labels on the current screen"
-"Extract the phone number displayed"
+
+```python
+# Simple command
+goal: "Go to settings and tell me my current battery level"
+
+# Data extraction with structured output
+goal: "Open Gmail, find first 3 unread emails, and list their sender and subject line"
+output_description: "A JSON list of objects, each with 'sender' and 'subject' keys"
+
+# App navigation
+goal: "Open Twitter and scroll to the latest tweet"
 ```
 
+The tool will:
+
+1. Find the specified device (or first available)
+2. Execute the command using the mobile-use AI agent
+3. Return the result or extracted data
+
+### Tool: `save_figma_assets`
+
+Fetch Figma design assets and React implementation code, then save them locally in the workspace.
+
+**Parameters:**
+
+- `node_id` (required): The node ID of the Figma design in format "1:2" (colon-separated). Extract from URLs like `https://figma.com/design/:fileKey/:fileName?node-id=1-2`
+- `file_key` (required): The file key from the Figma URL (e.g., "abc123" from `https://figma.com/design/abc123/MyFile`)
+- `workspace_path` (optional): The workspace path where assets should be saved. Defaults to current directory.
+
+**Returns:** Download summary with list of successfully downloaded assets and any failures.
+
+**Example:**
+
+```python
+node_id: "1:2"
+file_key: "abc123xyz"
+workspace_path: "."
+```
+
+The tool will:
+
+1. Call `get_design_context` from Figma MCP to get React/TypeScript code
+2. Extract all asset URLs from the code implementation
+3. Download each asset to `.mobile-use/figma_assets/<node-id>/` folder
+4. Save the code implementation to `.mobile-use/figma_assets/<node-id>/code_implementation.ts`
+5. Return a list of downloaded files with success/failure status
+
+### Tool: `compare_screenshot_with_figma`
+
+Compare a screenshot of the current mobile device state with a Figma design to identify visual differences.
+
+**Parameters:**
+
+- `node_id` (required): The node ID of the Figma design in format "1:2" (colon-separated). Extract from URLs like `https://figma.com/design/:fileKey/:fileName?node-id=1-2`
+
+**Returns:** Detailed comparison report with both the Figma design and current device screenshots for visual context.
+
+The tool will:
+
+1. Capture a screenshot of the current device state
+2. Fetch the Figma design screenshot
+3. Compare both screenshots using vision AI
+4. Return a detailed analysis highlighting differences
+
 ## Advanced Configuration
 
 ### Custom ADB Server

minitap_mcp-0.5.0/PYPI_README.md

@@ -0,0 +1,269 @@
+# Minitap MCP Server
+
+A Model Context Protocol (MCP) server that enables AI assistants to control and interact with real mobile devices (Android & iOS) through natural language commands.
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install minitap-mcp
+```
+
+### Prerequisites
+
+Before running the MCP server, ensure you have the required mobile automation tools installed:
+
+- **For Android devices:**
+  - [ADB (Android Debug Bridge)](https://developer.android.com/tools/adb) - For device communication
+  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
+
+- **For iOS devices (macOS only):**
+  - Xcode Command Line Tools with `xcrun`
+  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
+
+For detailed setup instructions, see the [mobile-use repository](https://github.com/minitap-ai/mobile-use).
+
+### Running the Server
+
+The simplest way to start:
+
+```bash
+minitap-mcp --server --api-key your_minitap_api_key
+```
+
+This starts the server on `localhost:8000` with your API key. Get your free API key at [platform.minitap.ai/api-keys](https://platform.minitap.ai/api-keys).
+
+**Available CLI options:**
+
+```bash
+minitap-mcp --server --api-key YOUR_KEY --llm-profile PROFILE_NAME
+```
+
+- `--api-key`: Your Minitap API key (overrides `MINITAP_API_KEY` env var). Get yours at [platform.minitap.ai/api-keys](https://platform.minitap.ai/api-keys).
+- `--llm-profile`: LLM profile name to use (overrides `MINITAP_LLM_PROFILE_NAME` env var). If unset, uses the default profile. Configure profiles at [platform.minitap.ai/llm-profiles](https://platform.minitap.ai/llm-profiles).
+
+### Configuration (Optional)
+
+Alternatively, you can set environment variables instead of using CLI flags:
+
+```bash
+export MINITAP_API_KEY="your_minitap_api_key"
+export MINITAP_API_BASE_URL="https://platform.minitap.ai/api/v1"
+export MINITAP_LLM_PROFILE_NAME="default"
+```
+
+You can set these in your `.bashrc` or equivalent, then simply run:
+
+```bash
+minitap-mcp --server
+```
+
+CLI flags always override environment variables when both are present.
+
+By default, the server will bind to `0.0.0.0:8000`. You can customize the port:
+
+```bash
+# Using CLI argument
+minitap-mcp --server --port 9000
+
+# Or using environment variable
+export MCP_SERVER_PORT="9000"
+minitap-mcp --server
+
+# You can also customize the host
+export MCP_SERVER_HOST="0.0.0.0"
+```
+
+## IDE Integration
+
+1. Start the server: `minitap-mcp --server --api-key your_minitap_api_key`
+2. Add to your IDE MCP settings file:
+
+```jsonc
+# For Windsurf
+{
+  "mcpServers": {
+    "minitap-mcp": {
+      "serverUrl": "http://localhost:8000/mcp"
+    }
+  }
+}
+```
+
+```jsonc
+# For Cursor
+{
+  "mcpServers": {
+    "minitap-mcp": {
+      "transport": "http",
+      "url": "http://localhost:8000/mcp"
+    }
+  }
+}
+```
+
+
+## Available Resources & Tools
+
+Once connected, your AI assistant can use these resources and tools:
+
+### Resource: `data://devices`
+
+Lists all connected mobile devices (Android and iOS).
+
+**Returns:** Array of device information objects with:
+
+- `device_id`: Device serial (Android) or UDID (iOS)
+- `platform`: `"android"` or `"ios"`
+- `name`: Device name
+- `state`: Device state (`"connected"` or `"Booted"`)
+
+### Tool: `analyze_screen`
+
+Captures a screenshot from a mobile device and analyzes it using a vision language model.
+
+**Parameters:**
+
+- `prompt` (required): Analysis prompt describing what information to extract
+- `device_id` (optional): Specific device ID to target. If not provided, uses the first available device.
+
+**Returns:** AI-generated analysis of the screenshot based on the prompt.
+
+**Example:**
+
+```
+Prompt: "What app is currently open? List all visible UI elements."
+```
+
+The tool will:
+
+1. Find the specified device (or first available)
+2. Capture a screenshot
+3. Analyze it with the vision model
+4. Return the analysis
+
+### Tool: `execute_mobile_command`
+
+Execute natural language commands on your mobile device using the mobile-use SDK. This tool allows you to control your Android or iOS device with simple instructions.
+
+**Parameters:**
+
+- `goal` (required): Natural language command to execute on the device
+- `output_description` (optional): Description of the expected output format (e.g., "A JSON list of objects with sender and subject keys")
+- `profile` (optional): Name of the profile to use for this task. Defaults to 'default'
+
+**Returns:** Execution result with status, output, and any extracted data.
+
+**Examples:**
+
+```python
+# Simple command
+goal: "Go to settings and tell me my current battery level"
+
+# Data extraction with structured output
+goal: "Open Gmail, find first 3 unread emails, and list their sender and subject line"
+output_description: "A JSON list of objects, each with 'sender' and 'subject' keys"
+
+# App navigation
+goal: "Open Twitter and scroll to the latest tweet"
+```
+
+The tool will:
+
+1. Find the specified device (or first available)
+2. Execute the command using the mobile-use AI agent
+3. Return the result or extracted data
+
+### Tool: `save_figma_assets`
+
+Fetch Figma design assets and React implementation code, then save them locally in the workspace.
+
+**Parameters:**
+
+- `node_id` (required): The node ID of the Figma design in format "1:2" (colon-separated). Extract from URLs like `https://figma.com/design/:fileKey/:fileName?node-id=1-2`
+- `file_key` (required): The file key from the Figma URL (e.g., "abc123" from `https://figma.com/design/abc123/MyFile`)
+- `workspace_path` (optional): The workspace path where assets should be saved. Defaults to current directory.
+
+**Returns:** Download summary with list of successfully downloaded assets and any failures.
+
+**Example:**
+
+```python
+node_id: "1:2"
+file_key: "abc123xyz"
+workspace_path: "."
+```
+
+The tool will:
+
+1. Call `get_design_context` from Figma MCP to get React/TypeScript code
+2. Extract all asset URLs from the code implementation
+3. Download each asset to `.mobile-use/figma_assets/<node-id>/` folder
+4. Save the code implementation to `.mobile-use/figma_assets/<node-id>/code_implementation.ts`
+5. Return a list of downloaded files with success/failure status
+
+### Tool: `compare_screenshot_with_figma`
+
+Compare a screenshot of the current mobile device state with a Figma design to identify visual differences.
+
+**Parameters:**
+
+- `node_id` (required): The node ID of the Figma design in format "1:2" (colon-separated). Extract from URLs like `https://figma.com/design/:fileKey/:fileName?node-id=1-2`
+
+**Returns:** Detailed comparison report with both the Figma design and current device screenshots for visual context.
+
+The tool will:
+
+1. Capture a screenshot of the current device state
+2. Fetch the Figma design screenshot
+3. Compare both screenshots using vision AI
+4. Return a detailed analysis highlighting differences
+
+## Advanced Configuration
+
+### Custom ADB Server
+
+If using a remote or custom ADB server (like on WSL):
+
+```bash
+export ADB_SERVER_SOCKET="tcp:192.168.1.100:5037"
+```
+
+### Vision Model
+
+Customize the vision model used for screen analysis:
+
+```bash
+export VISION_MODEL="qwen/qwen-2.5-vl-7b-instruct"
+```
+
+## Device Setup
+
+### Android
+1. Enable USB debugging on your device
+2. Connect via USB or network ADB
+3. Verify connection: `adb devices`
+
+### iOS (macOS only)
+1. Install Xcode Command Line Tools
+2. Start a simulator or connect a physical device
+3. Verify: `xcrun simctl list devices booted`
+
+## Troubleshooting
+
+**No devices found:**
+- Verify ADB/xcrun connection
+- Check USB debugging is enabled (Android)
+- Ensure device is unlocked
+
+**Connection refused errors:**
+- Check ADB/xcrun connection
+
+**API authentication errors:**
+- Verify `MINITAP_API_KEY` is set correctly
+
+## Links
+
+- **Mobile-Use SDK:** [github.com/minitap-ai/mobile-use](https://github.com/minitap-ai/mobile-use)
+- **Mobile-Use Documentation:** [docs.minitap.ai](https://docs.minitap.ai)

minitap_mcp-0.5.0/minitap/mcp/core/agents/extract_figma_assets.py

@@ -0,0 +1,69 @@
+"""Agent to extract Figma asset URLs from design context code using regex."""
+
+import re
+
+from pydantic import BaseModel, Field
+
+
+class FigmaAsset(BaseModel):
+    """Represents a single Figma asset."""
+
+    variable_name: str = Field(description="The variable name from the code (e.g., imgSignal)")
+    url: str = Field(description="The full URL to the asset")
+    extension: str = Field(description="The file extension (e.g., svg, png, jpg)")
+
+
+class ExtractedAssets(BaseModel):
+    """Container for all extracted Figma assets."""
+
+    assets: list[FigmaAsset] = Field(
+        default_factory=list,
+        description="List of all extracted assets from the Figma design context",
+    )
+    code_implementation: str = Field(
+        description="The React/TypeScript code with imports instead of const declarations"
+    )
+
+
+def extract_figma_assets(design_context_code: str) -> ExtractedAssets:
+    """Extract asset URLs from Figma design context code using regex.
+
+    Args:
+        design_context_code: The React/TypeScript code from get_design_context
+
+    Returns:
+        ExtractedAssets with list of assets and transformed code
+    """
+    # Regex captures: (1) variable name, (2) full URL, (4) extension
+    # Supports http/https, any domain, query strings, optional semicolon
+    pattern = r'const\s+(\w+)\s*=\s*["\']((https?://[^"\']+?)\.(\w+)(?:\?[^"\']*)?)["\'];?'
+    matches = re.finditer(pattern, design_context_code)
+
+    assets = []
+    asset_lines = []
+
+    for match in matches:
+        var_name = match.group(1)
+        url = match.group(2)
+        extension = match.group(4)
+
+        assets.append(FigmaAsset(variable_name=var_name, url=url, extension=extension))
+        asset_lines.append(match.group(0))
+
+    import_statements = []
+    for asset in assets:
+        import_statements.append(
+            f"import {asset.variable_name} from './{asset.variable_name}.{asset.extension}';"
+        )
+
+    transformed_code = design_context_code
+    for line in asset_lines:
+        transformed_code = transformed_code.replace(line, "")
+
+    lines = transformed_code.split("\n")
+    while lines and not lines[0].strip():
+        lines.pop(0)
+
+    final_code = "\n".join(import_statements) + "\n\n" + "\n".join(lines)
+
+    return ExtractedAssets(assets=assets, code_implementation=final_code)

{minitap_mcp-0.4.2 → minitap_mcp-0.5.0}/minitap/mcp/tools/save_figma_assets.py

@@ -41,9 +41,9 @@ logger = get_logger(__name__)
     
     This tool:
     1. Calls get_design_context from Figma MCP to get the React/TypeScript code
-    2. Extracts all asset URLs and code implementation from the code
+    2. Extracts asset URLs and transforms const declarations to import statements
     3. Downloads each asset to .mobile-use/figma_assets/<node-id>/ folder
-    4. Saves the code implementation to .mobile-use/figma_assets/<node-id>/code_implementation.ts
+    4. Saves the transformed code to .mobile-use/figma_assets/<node-id>/code_implementation.ts
     5. Returns a list of downloaded files
     """,
 )
@@ -75,10 +75,8 @@ async def save_figma_assets(
     # Step 1: Get design context from Figma MCP
     design_context = await get_design_context(node_id, file_key)
 
-    # Step 2: Extract asset URLs using LLM agent
-    extracted_context: ExtractedAssets = await extract_figma_assets(
-        design_context.code_implementation
-    )
+    # Step 2: Extract asset URLs and transform code
+    extracted_context: ExtractedAssets = extract_figma_assets(design_context.code_implementation)
     if not extracted_context.assets:
         raise ToolError("No assets found in the Figma design context.")
 

{minitap_mcp-0.4.2 → minitap_mcp-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitap-mcp"
-version = "0.4.2"
+version = "0.5.0"
 description = "Model Context Protocol server for controlling Android & iOS devices with natural language"
 readme = "PYPI_README.md"
 

minitap_mcp-0.4.2/PYPI_README.md

@@ -1,181 +0,0 @@
-# Minitap MCP Server
-
-A Model Context Protocol (MCP) server that enables AI assistants to control and interact with real mobile devices (Android & iOS) through natural language commands.
-
-## Quick Start
-
-### Installation
-
-```bash
-pip install minitap-mcp
-```
-
-### Prerequisites
-
-Before running the MCP server, ensure you have the required mobile automation tools installed:
-
-- **For Android devices:**
-  - [ADB (Android Debug Bridge)](https://developer.android.com/tools/adb) - For device communication
-  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
-
-- **For iOS devices (macOS only):**
-  - Xcode Command Line Tools with `xcrun`
-  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
-
-For detailed setup instructions, see the [mobile-use repository](https://github.com/minitap-ai/mobile-use).
-
-### Running the Server
-
-The simplest way to start:
-
-```bash
-minitap-mcp --server --api-key your_minitap_api_key
-```
-
-This starts the server on `localhost:8000` with your API key. Get your free API key at [platform.minitap.ai/api-keys](https://platform.minitap.ai/api-keys).
-
-**Available CLI options:**
-
-```bash
-minitap-mcp --server --api-key YOUR_KEY --llm-profile PROFILE_NAME
-```
-
-- `--api-key`: Your Minitap API key (overrides `MINITAP_API_KEY` env var). Get yours at [platform.minitap.ai/api-keys](https://platform.minitap.ai/api-keys).
-- `--llm-profile`: LLM profile name to use (overrides `MINITAP_LLM_PROFILE_NAME` env var). If unset, uses the default profile. Configure profiles at [platform.minitap.ai/llm-profiles](https://platform.minitap.ai/llm-profiles).
-
-### Configuration (Optional)
-
-Alternatively, you can set environment variables instead of using CLI flags:
-
-```bash
-export MINITAP_API_KEY="your_minitap_api_key"
-export MINITAP_API_BASE_URL="https://platform.minitap.ai/api/v1"
-export MINITAP_LLM_PROFILE_NAME="default"
-```
-
-You can set these in your `.bashrc` or equivalent, then simply run:
-
-```bash
-minitap-mcp --server
-```
-
-CLI flags always override environment variables when both are present.
-
-By default, the server will bind to `0.0.0.0:8000`. Configure via environment variables:
-
-```bash
-export MCP_SERVER_HOST="0.0.0.0"
-export MCP_SERVER_PORT="8000"
-```
-
-## IDE Integration
-
-1. Start the server: `minitap-mcp --server --api-key your_minitap_api_key`
-2. Add to your IDE MCP settings file:
-
-```jsonc
-# For Windsurf
-{
-  "mcpServers": {
-    "minitap-mcp": {
-      "serverUrl": "http://localhost:8000/mcp"
-    }
-  }
-}
-```
-
-```jsonc
-# For Cursor
-{
-  "mcpServers": {
-    "minitap-mcp": {
-      "transport": "http",
-      "url": "http://localhost:8000/mcp"
-    }
-  }
-}
-```
-
-
-## Available Tools
-
-Once connected, your AI assistant can use these tools:
-
-### `execute_mobile_command`
-Execute natural language commands on your mobile device using the Minitap SDK. This tool allows you to control your Android or iOS device using natural language.
-
-**Parameters:**
-- `goal` (required): High-level goal describing the action to perform
-- `output_description` (optional): Natural language description of the desired output format. Results are returned as structured JSON (e.g., "An array with sender and subject for each email")
-- `profile` (optional): Profile name to use (defaults to "default")
-
-**Examples:**
-```
-"Open the settings app and tell me the battery level"
-"Find the first 3 unread emails in Gmail"
-"Open Google Maps and search for the nearest coffee shop"
-"Take a screenshot and save it"
-```
-
-### `analyze_screen`
-Capture and analyze what's currently shown on the mobile device screen using a vision-capable LLM. Useful for understanding UI elements, extracting text, or identifying specific features.
-
-**Parameters:**
-- `prompt` (required): Analysis prompt describing what information to extract
-- `device_id` (optional): Specific device ID to target
-
-**Examples:**
-```js
-"What app is currently open?"
-"Read the text messages visible on screen"
-"List all buttons and their labels on the current screen"
-"Extract the phone number displayed"
-```
-
-## Advanced Configuration
-
-### Custom ADB Server
-
-If using a remote or custom ADB server (like on WSL):
-
-```bash
-export ADB_SERVER_SOCKET="tcp:192.168.1.100:5037"
-```
-
-### Vision Model
-
-Customize the vision model used for screen analysis:
-
-```bash
-export VISION_MODEL="qwen/qwen-2.5-vl-7b-instruct"
-```
-
-## Device Setup
-
-### Android
-1. Enable USB debugging on your device
-2. Connect via USB or network ADB
-3. Verify connection: `adb devices`
-
-### iOS (macOS only)
-1. Install Xcode Command Line Tools
-2. Start a simulator or connect a physical device
-3. Verify: `xcrun simctl list devices booted`
-
-## Troubleshooting
-
-**No devices found:**
-- Verify ADB/xcrun connection
-- Check USB debugging is enabled (Android)
-- Ensure device is unlocked
-
-**Connection refused errors:**
-- Check ADB/xcrun connection
-
-**API authentication errors:**
-- Verify `MINITAP_API_KEY` is set correctly
-
-## Links
-
-- **Mobile-Use SDK:** [github.com/minitap-ai/mobile-use](https://github.com/minitap-ai/mobile-use)
-- **Mobile-Use Documentation:** [docs.minitap.ai](https://docs.minitap.ai)

minitap_mcp-0.4.2/minitap/mcp/core/agents/extract_figma_assets.md

@@ -1,64 +0,0 @@
-You are an expert at parsing React/TypeScript code to extract asset URLs and generate clean, documented code implementations.
-
-Your task is to:
-
-1. Extract all asset URLs from the provided code snippet
-2. Generate a clean `code_implementation` output that includes the React code with embedded comments referencing implementation and node guidelines
-
-**Instructions:**
-
-## Part 1: Extract Asset URLs
-
-1. Look for all constant declarations that contain URLs pointing to assets (images, SVGs, etc.)
-2. These constants typically follow patterns like:
-
-   - `const imgVariableName = "http://localhost:3845/assets/[hash].[extension]";`
-   - The variable names usually start with `img` followed by a descriptive name in camelCase
-
-3. For each asset URL found, extract:
-   - The **variable name** (e.g., `imgSignal`, `imgBatteryThreeQuarters`)
-   - The **full URL** (e.g., `http://localhost:3845/assets/685c5ac58caa29556e29737cf8f8c9605d9c8571.svg`)
-   - The **file extension** from the URL (e.g., `svg`, `png`, `jpg`)
-
-## Part 2: Generate Code Implementation
-
-The `code_implementation` field should contain:
-
-1. The React/TypeScript code with **LOCAL asset imports** instead of HTTP URLs:
-
-   - Convert `const imgSignal = "http://localhost:3845/assets/[hash].svg";`
-   - To `import imgSignal from './assets/imgSignal.svg';` (or appropriate relative path)
-   - Use the **exact same variable names** as in the original const declarations
-   - **CRITICAL**: Preserve the variable naming convention
-
-2. Preserve all `data-node-id` attributes and other metadata in the code
-
-## Part 3: Return Format
-
-Return a JSON object with two fields:
-
-- `assets`: Array of extracted asset objects
-- `code_implementation`: String containing the React code with embedded guideline comments
-
-```json
-{
-  "assets": [
-    {
-      "variable_name": "imgSignal",
-      "url": "http://localhost:3845/assets/685c5ac58caa29556e29737cf8f8c9605d9c8571.svg",
-      "extension": "svg"
-    },
-    ...
-  ],
-  "code_implementation": "import ... function ..."
-}
-```
-
-**Important:**
-
-- Only extract asset URLs
-- Preserve the exact variable names as they appear in the code
-- DO NOT MISS any assets
-- If no assets are found, return an empty array for `assets`
-- Return ONLY the JSON object with both `assets` and `code_implementation` fields
-- Do NOT include the const declarations of the assets in the code_implementation output - convert them to imports.

minitap_mcp-0.4.2/minitap/mcp/core/agents/extract_figma_assets.py

@@ -1,96 +0,0 @@
-"""Agent to extract Figma asset URLs from design context code."""
-
-import re
-import uuid
-from pathlib import Path
-
-from jinja2 import Template
-from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
-from pydantic import BaseModel, Field
-
-from minitap.mcp.core.llm import get_minitap_llm
-
-
-class FigmaAsset(BaseModel):
-    """Represents a single Figma asset."""
-
-    variable_name: str = Field(description="The variable name from the code (e.g., imgSignal)")
-    url: str = Field(description="The full URL to the asset")
-    extension: str = Field(description="The file extension (e.g., svg, png, jpg)")
-
-
-class ExtractedAssets(BaseModel):
-    """Container for all extracted Figma assets."""
-
-    assets: list[FigmaAsset] = Field(
-        default_factory=list,
-        description="List of all extracted assets from the Figma design context",
-    )
-    code_implementation: str = Field(
-        description=(
-            "The React/TypeScript code\n"
-            "with the local url declarations turned into const declarations"
-        )
-    )
-
-
-def sanitize_unicode_for_llm(text: str) -> str:
-    """Remove or replace problematic Unicode characters that increase token consumption.
-
-    Characters outside the Basic Multilingual Plane (BMP) like emoji and special symbols
-    get escaped as \\U sequences when sent to LLMs, dramatically increasing token count
-    and processing time.
-
-    Args:
-        text: The text to sanitize
-
-    Returns:
-        Text with problematic Unicode characters replaced with placeholders
-    """
-
-    # Replace characters outside BMP (U+10000 and above) with a placeholder
-    # These are typically emoji, special symbols, or rare characters
-    def replace_high_unicode(match):
-        char = match.group(0)
-        codepoint = ord(char)
-        # Return a descriptive placeholder
-        return f"[U+{codepoint:X}]"
-
-    # Pattern matches characters with codepoints >= U+10000
-    pattern = re.compile(r"[\U00010000-\U0010FFFF]")
-    sanitized = pattern.sub(replace_high_unicode, text)
-
-    return sanitized
-
-
-async def extract_figma_assets(design_context_code: str) -> ExtractedAssets:
-    """Extract asset URLs from Figma design context code.
-
-    Args:
-        design_context_code: The React/TypeScript code from get_design_context
-
-    Returns:
-        List of dictionaries containing variable_name, url, and extension
-    """
-    system_message = Template(
-        Path(__file__).parent.joinpath("extract_figma_assets.md").read_text(encoding="utf-8")
-    ).render()
-
-    sanitized_code = sanitize_unicode_for_llm(design_context_code)
-
-    messages: list[BaseMessage] = [
-        SystemMessage(content=system_message),
-        HumanMessage(
-            content=f"Here is the code to analyze:\n\n```typescript\n{sanitized_code}\n```"
-        ),
-    ]
-
-    llm = get_minitap_llm(
-        model="openai/gpt-5",
-        temperature=0,
-        trace_id=str(uuid.uuid4()),
-        remote_tracing=True,
-    ).with_structured_output(ExtractedAssets)
-    result: ExtractedAssets = await llm.ainvoke(messages)  # type: ignore
-
-    return result