@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/skills/meshy/scripts/check_status.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "httpx>=0.25.0",
+# ]
+# ///
+"""
+Check the status of a Meshy AI generation task.
+
+Usage:
+    uv run check_status.py --task-id "task_xxxxx"
+    uv run check_status.py --task-id "task_xxxxx" --type image-to-3d
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import httpx
+
+API_BASE = "https://api.meshy.ai/v2"
+
+
+def get_api_key(provided_key: str | None) -> str | None:
+    """Get API key from argument first, then environment."""
+    if provided_key:
+        return provided_key
+    return os.environ.get("MESHY_API_KEY")
+
+
+def get_task_status(client: httpx.Client, task_id: str, task_type: str) -> dict:
+    """Get the status of a generation task."""
+    response = client.get(f"{API_BASE}/{task_type}/{task_id}")
+    response.raise_for_status()
+    return response.json()
+
+
+def download_model(client: httpx.Client, url: str, output_path: Path) -> None:
+    """Download the generated 3D model."""
+    response = client.get(url)
+    response.raise_for_status()
+    output_path.write_bytes(response.content)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Check Meshy AI task status"
+    )
+    parser.add_argument(
+        "--task-id", "-t",
+        required=True,
+        help="Task ID to check"
+    )
+    parser.add_argument(
+        "--type",
+        choices=["text-to-3d", "image-to-3d"],
+        default="text-to-3d",
+        help="Task type (default: text-to-3d)"
+    )
+    parser.add_argument(
+        "--download", "-d",
+        help="Download model to this path if task is complete"
+    )
+    parser.add_argument(
+        "--api-key", "-k",
+        help="Meshy API key (overrides MESHY_API_KEY env var)"
+    )
+
+    args = parser.parse_args()
+
+    # Get API key
+    api_key = get_api_key(args.api_key)
+    if not api_key:
+        print("Error: No API key provided.", file=sys.stderr)
+        print("Please either:", file=sys.stderr)
+        print("  1. Provide --api-key argument", file=sys.stderr)
+        print("  2. Set MESHY_API_KEY environment variable", file=sys.stderr)
+        sys.exit(1)
+
+    # Create HTTP client with auth
+    with httpx.Client(
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=60.0,
+    ) as client:
+        try:
+            status = get_task_status(client, args.task_id, args.type)
+
+            task_status = status.get("status", "UNKNOWN")
+            progress = status.get("progress", 0)
+
+            print(f"Task ID: {args.task_id}")
+            print(f"Type: {args.type}")
+            print(f"Status: {task_status}")
+            print(f"Progress: {progress}%")
+
+            if task_status == "SUCCEEDED":
+                model_urls = status.get("model_urls", {})
+                print("\nModel URLs:")
+                for fmt, url in model_urls.items():
+                    print(f"  {fmt}: {url[:80]}...")
+
+                if args.download:
+                    glb_url = model_urls.get("glb")
+                    if glb_url:
+                        output_path = Path(args.download)
+                        output_path.parent.mkdir(parents=True, exist_ok=True)
+                        print(f"\nDownloading to: {output_path}")
+                        download_model(client, glb_url, output_path)
+                        full_path = output_path.resolve()
+                        print(f"3D Model saved: {full_path}")
+                        print(f"MEDIA:{full_path}")
+                    else:
+                        print("\nNo GLB URL available for download.", file=sys.stderr)
+
+            elif task_status == "FAILED":
+                error_info = status.get("task_error", {})
+                error_msg = error_info.get("message", "Unknown error")
+                print(f"\nError: {error_msg}")
+
+            elif task_status in ("PENDING", "IN_PROGRESS"):
+                print("\nTask is still processing. Check again later.")
+
+            # Print additional info if available
+            if "prompt" in status:
+                print(f"\nPrompt: {status['prompt']}")
+            if "art_style" in status:
+                print(f"Style: {status['art_style']}")
+            if "thumbnail_url" in status:
+                print(f"Thumbnail: {status['thumbnail_url']}")
+
+        except httpx.HTTPStatusError as e:
+            print(f"Error: API request failed - {e.response.status_code}", file=sys.stderr)
+            try:
+                error_detail = e.response.json()
+                print(f"  Detail: {error_detail}", file=sys.stderr)
+            except Exception:
+                print(f"  Response: {e.response.text}", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/meshy/scripts/image_to_3d.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "httpx>=0.25.0",
+# ]
+# ///
+"""
+Generate 3D models from images using Meshy AI API.
+
+Usage:
+    uv run image_to_3d.py --image "reference.png" --filename "model.glb"
+"""
+
+import argparse
+import base64
+import mimetypes
+import os
+import sys
+import time
+from pathlib import Path
+
+import httpx
+
+API_BASE = "https://api.meshy.ai/v2"
+POLL_INTERVAL = 10  # seconds
+MAX_WAIT_TIME = 600  # 10 minutes
+
+
+def get_api_key(provided_key: str | None) -> str | None:
+    """Get API key from argument first, then environment."""
+    if provided_key:
+        return provided_key
+    return os.environ.get("MESHY_API_KEY")
+
+
+def encode_image_to_data_url(image_path: Path) -> str:
+    """Encode an image file to a data URL."""
+    mime_type, _ = mimetypes.guess_type(str(image_path))
+    if not mime_type:
+        mime_type = "image/png"
+
+    with open(image_path, "rb") as f:
+        image_data = base64.b64encode(f.read()).decode("utf-8")
+
+    return f"data:{mime_type};base64,{image_data}"
+
+
+def create_image_to_3d_task(
+    client: httpx.Client,
+    image_url: str,
+    topology: str,
+    target_polycount: int,
+) -> str:
+    """Create an image-to-3D generation task and return the task ID."""
+    response = client.post(
+        f"{API_BASE}/image-to-3d",
+        json={
+            "image_url": image_url,
+            "topology": topology,
+            "target_polycount": target_polycount,
+        },
+    )
+    response.raise_for_status()
+    data = response.json()
+    return data["result"]
+
+
+def get_task_status(client: httpx.Client, task_id: str) -> dict:
+    """Get the status of a generation task."""
+    response = client.get(f"{API_BASE}/image-to-3d/{task_id}")
+    response.raise_for_status()
+    return response.json()
+
+
+def download_model(client: httpx.Client, url: str, output_path: Path) -> None:
+    """Download the generated 3D model."""
+    response = client.get(url)
+    response.raise_for_status()
+    output_path.write_bytes(response.content)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate 3D models from images using Meshy AI"
+    )
+    parser.add_argument(
+        "--image", "-i",
+        required=True,
+        help="Input image path or URL"
+    )
+    parser.add_argument(
+        "--filename", "-f",
+        required=True,
+        help="Output filename (e.g., model.glb)"
+    )
+    parser.add_argument(
+        "--topology", "-t",
+        choices=["quad", "triangle"],
+        default="quad",
+        help="Mesh topology (default: quad)"
+    )
+    parser.add_argument(
+        "--target-polycount",
+        type=int,
+        default=30000,
+        help="Target polygon count (default: 30000)"
+    )
+    parser.add_argument(
+        "--api-key", "-k",
+        help="Meshy API key (overrides MESHY_API_KEY env var)"
+    )
+    parser.add_argument(
+        "--no-wait",
+        action="store_true",
+        help="Don't wait for completion, just return task ID"
+    )
+
+    args = parser.parse_args()
+
+    # Get API key
+    api_key = get_api_key(args.api_key)
+    if not api_key:
+        print("Error: No API key provided.", file=sys.stderr)
+        print("Please either:", file=sys.stderr)
+        print("  1. Provide --api-key argument", file=sys.stderr)
+        print("  2. Set MESHY_API_KEY environment variable", file=sys.stderr)
+        sys.exit(1)
+
+    # Set up output path
+    output_path = Path(args.filename)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Process image input
+    image_input = args.image
+    if image_input.startswith(("http://", "https://", "data:")):
+        image_url = image_input
+        print(f"Using image URL: {image_url[:80]}...")
+    else:
+        # Local file - convert to data URL
+        image_path = Path(image_input)
+        if not image_path.exists():
+            print(f"Error: Image file not found: {image_path}", file=sys.stderr)
+            sys.exit(1)
+        print(f"Encoding local image: {image_path}")
+        image_url = encode_image_to_data_url(image_path)
+
+    # Create HTTP client with auth
+    with httpx.Client(
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=60.0,
+    ) as client:
+        print(f"Creating image-to-3D task...")
+        print(f"  Topology: {args.topology}")
+        print(f"  Target polycount: {args.target_polycount}")
+
+        try:
+            task_id = create_image_to_3d_task(
+                client,
+                image_url=image_url,
+                topology=args.topology,
+                target_polycount=args.target_polycount,
+            )
+            print(f"Task created: {task_id}")
+
+            if args.no_wait:
+                print(f"Task ID: {task_id}")
+                print("Use check_status.py to monitor progress.")
+                return
+
+            # Poll for completion
+            print("Waiting for generation to complete...")
+            start_time = time.time()
+            while True:
+                elapsed = time.time() - start_time
+                if elapsed > MAX_WAIT_TIME:
+                    print(f"Error: Task timed out after {MAX_WAIT_TIME} seconds.", file=sys.stderr)
+                    print(f"Task ID: {task_id}", file=sys.stderr)
+                    sys.exit(1)
+
+                status = get_task_status(client, task_id)
+                task_status = status.get("status", "UNKNOWN")
+
+                if task_status == "SUCCEEDED":
+                    print("Generation complete!")
+                    model_urls = status.get("model_urls", {})
+                    glb_url = model_urls.get("glb")
+
+                    if not glb_url:
+                        print("Error: No GLB model URL in response.", file=sys.stderr)
+                        sys.exit(1)
+
+                    print(f"Downloading model...")
+                    download_model(client, glb_url, output_path)
+
+                    full_path = output_path.resolve()
+                    print(f"\n3D Model saved: {full_path}")
+                    print(f"MEDIA:{full_path}")
+                    return
+
+                elif task_status == "FAILED":
+                    error_msg = status.get("task_error", {}).get("message", "Unknown error")
+                    print(f"Error: Task failed - {error_msg}", file=sys.stderr)
+                    sys.exit(1)
+
+                elif task_status in ("PENDING", "IN_PROGRESS"):
+                    progress = status.get("progress", 0)
+                    print(f"  Status: {task_status} ({progress}%) - {int(elapsed)}s elapsed")
+                    time.sleep(POLL_INTERVAL)
+
+                else:
+                    print(f"  Status: {task_status} - {int(elapsed)}s elapsed")
+                    time.sleep(POLL_INTERVAL)
+
+        except httpx.HTTPStatusError as e:
+            print(f"Error: API request failed - {e.response.status_code}", file=sys.stderr)
+            try:
+                error_detail = e.response.json()
+                print(f"  Detail: {error_detail}", file=sys.stderr)
+            except Exception:
+                print(f"  Response: {e.response.text}", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/meshy/scripts/text_to_3d.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "httpx>=0.25.0",
+# ]
+# ///
+"""
+Generate 3D models from text using Meshy AI API.
+
+Usage:
+    uv run text_to_3d.py --prompt "a cute robot" --filename "robot.glb"
+    uv run text_to_3d.py --prompt "medieval sword" --filename "sword.glb" --style realistic
+"""
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+
+import httpx
+
+API_BASE = "https://api.meshy.ai/v2"
+POLL_INTERVAL = 10  # seconds
+MAX_WAIT_TIME = 600  # 10 minutes
+
+
+def get_api_key(provided_key: str | None) -> str | None:
+    """Get API key from argument first, then environment."""
+    if provided_key:
+        return provided_key
+    return os.environ.get("MESHY_API_KEY")
+
+
+def create_text_to_3d_task(
+    client: httpx.Client,
+    prompt: str,
+    style: str,
+    topology: str,
+    target_polycount: int,
+) -> str:
+    """Create a text-to-3D generation task and return the task ID."""
+    response = client.post(
+        f"{API_BASE}/text-to-3d",
+        json={
+            "mode": "preview",
+            "prompt": prompt,
+            "art_style": style,
+            "topology": topology,
+            "target_polycount": target_polycount,
+        },
+    )
+    response.raise_for_status()
+    data = response.json()
+    return data["result"]
+
+
+def get_task_status(client: httpx.Client, task_id: str) -> dict:
+    """Get the status of a generation task."""
+    response = client.get(f"{API_BASE}/text-to-3d/{task_id}")
+    response.raise_for_status()
+    return response.json()
+
+
+def download_model(client: httpx.Client, url: str, output_path: Path) -> None:
+    """Download the generated 3D model."""
+    response = client.get(url)
+    response.raise_for_status()
+    output_path.write_bytes(response.content)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate 3D models from text using Meshy AI"
+    )
+    parser.add_argument(
+        "--prompt", "-p",
+        required=True,
+        help="Text description of the 3D model to generate"
+    )
+    parser.add_argument(
+        "--filename", "-f",
+        required=True,
+        help="Output filename (e.g., model.glb)"
+    )
+    parser.add_argument(
+        "--style", "-s",
+        choices=["realistic", "cartoon", "sculpture", "pbr"],
+        default="realistic",
+        help="Art style (default: realistic)"
+    )
+    parser.add_argument(
+        "--topology", "-t",
+        choices=["quad", "triangle"],
+        default="quad",
+        help="Mesh topology (default: quad)"
+    )
+    parser.add_argument(
+        "--target-polycount",
+        type=int,
+        default=30000,
+        help="Target polygon count (default: 30000)"
+    )
+    parser.add_argument(
+        "--api-key", "-k",
+        help="Meshy API key (overrides MESHY_API_KEY env var)"
+    )
+    parser.add_argument(
+        "--no-wait",
+        action="store_true",
+        help="Don't wait for completion, just return task ID"
+    )
+
+    args = parser.parse_args()
+
+    # Get API key
+    api_key = get_api_key(args.api_key)
+    if not api_key:
+        print("Error: No API key provided.", file=sys.stderr)
+        print("Please either:", file=sys.stderr)
+        print("  1. Provide --api-key argument", file=sys.stderr)
+        print("  2. Set MESHY_API_KEY environment variable", file=sys.stderr)
+        sys.exit(1)
+
+    # Set up output path
+    output_path = Path(args.filename)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Create HTTP client with auth
+    with httpx.Client(
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=60.0,
+    ) as client:
+        print(f"Creating text-to-3D task...")
+        print(f"  Prompt: {args.prompt}")
+        print(f"  Style: {args.style}")
+        print(f"  Topology: {args.topology}")
+        print(f"  Target polycount: {args.target_polycount}")
+
+        try:
+            task_id = create_text_to_3d_task(
+                client,
+                prompt=args.prompt,
+                style=args.style,
+                topology=args.topology,
+                target_polycount=args.target_polycount,
+            )
+            print(f"Task created: {task_id}")
+
+            if args.no_wait:
+                print(f"Task ID: {task_id}")
+                print("Use check_status.py to monitor progress.")
+                return
+
+            # Poll for completion
+            print("Waiting for generation to complete...")
+            start_time = time.time()
+            while True:
+                elapsed = time.time() - start_time
+                if elapsed > MAX_WAIT_TIME:
+                    print(f"Error: Task timed out after {MAX_WAIT_TIME} seconds.", file=sys.stderr)
+                    print(f"Task ID: {task_id}", file=sys.stderr)
+                    sys.exit(1)
+
+                status = get_task_status(client, task_id)
+                task_status = status.get("status", "UNKNOWN")
+
+                if task_status == "SUCCEEDED":
+                    print("Generation complete!")
+                    model_urls = status.get("model_urls", {})
+                    glb_url = model_urls.get("glb")
+
+                    if not glb_url:
+                        print("Error: No GLB model URL in response.", file=sys.stderr)
+                        sys.exit(1)
+
+                    print(f"Downloading model...")
+                    download_model(client, glb_url, output_path)
+
+                    full_path = output_path.resolve()
+                    print(f"\n3D Model saved: {full_path}")
+                    print(f"MEDIA:{full_path}")
+                    return
+
+                elif task_status == "FAILED":
+                    error_msg = status.get("task_error", {}).get("message", "Unknown error")
+                    print(f"Error: Task failed - {error_msg}", file=sys.stderr)
+                    sys.exit(1)
+
+                elif task_status in ("PENDING", "IN_PROGRESS"):
+                    progress = status.get("progress", 0)
+                    print(f"  Status: {task_status} ({progress}%) - {int(elapsed)}s elapsed")
+                    time.sleep(POLL_INTERVAL)
+
+                else:
+                    print(f"  Status: {task_status} - {int(elapsed)}s elapsed")
+                    time.sleep(POLL_INTERVAL)
+
+        except httpx.HTTPStatusError as e:
+            print(f"Error: API request failed - {e.response.status_code}", file=sys.stderr)
+            try:
+                error_detail = e.response.json()
+                print(f"  Detail: {error_detail}", file=sys.stderr)
+            except Exception:
+                print(f"  Response: {e.response.text}", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/nano-banana-pro/scripts/generate_image.py

@@ -219,7 +219,7 @@ def main():
         if image_saved:
             full_path = output_path.resolve()
             print(f"\nImage saved: {full_path}")
-            # OpenClaw parses MEDIA: tokens and will attach the file on
+            # moldclaw parses MEDIA: tokens and will attach the file on
             # supported chat providers. Emit the canonical MEDIA:<path> form.
             print(f"MEDIA:{full_path}")
         else:

package/skills/tavily-search/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: Tavily Search
+description: AI-optimized web search using Tavily API.
+homepage: https://tavily.com
+metadata:
+  {
+    "moldclaw":
+      {
+        "emoji": "🔎",
+        "requires": { "bins": ["uv"], "env": ["TAVILY_API_KEY"] },
+        "primaryEnv": "TAVILY_API_KEY",
+        "install":
+          [
+            {
+              "id": "uv-brew",
+              "kind": "brew",
+              "formula": "uv",
+              "bins": ["uv"],
+              "label": "Install uv (brew)",
+            },
+          ],
+      },
+  }
+---
+
+# Tavily Search (AI-Optimized Web Search)
+
+Use the bundled script to perform AI-optimized web searches.
+
+## Basic Search
+
+```bash
+uv run {baseDir}/scripts/search.py --query "latest AI developments 2024"
+```
+
+## Search with Options
+
+```bash
+uv run {baseDir}/scripts/search.py --query "climate change solutions" --depth advanced --max-results 10
+```
+
+## Options
+
+- `--depth`: Search depth (`basic` or `advanced`). Default: basic
+- `--max-results`: Maximum number of results (1-20). Default: 5
+- `--include-domains`: Comma-separated list of domains to include
+- `--exclude-domains`: Comma-separated list of domains to exclude
+- `--include-answer`: Include AI-generated answer summary
+- `--include-raw-content`: Include raw page content
+- `--topic`: Search topic type (`general` or `news`). Default: general
+
+## API Key
+
+- `TAVILY_API_KEY` env var
+- Or set `skills."tavily-search".apiKey` / `skills."tavily-search".env.TAVILY_API_KEY` in `~/.moldclaw/moldclaw.json`
+
+## Notes
+
+- Tavily is optimized for AI agents and LLMs, providing clean, relevant results.
+- Use `--depth advanced` for more comprehensive results (uses more API credits).
+- The `--include-answer` flag provides an AI-generated summary of search results.