scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/_mcp_tools/audio.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-15
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/audio.py
+"""Audio module tools for FastMCP unified server."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+
+def _json(data: dict) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+def register_audio_tools(mcp) -> None:
+    """Register audio tools with FastMCP server."""
+
+    @mcp.tool()
+    async def audio_speak(
+        text: str,
+        backend: Optional[str] = None,
+        voice: Optional[str] = None,
+        rate: int = 150,
+        speed: float = 1.5,
+        play: bool = True,
+        save: bool = False,
+        fallback: bool = True,
+        agent_id: Optional[str] = None,
+        wait: bool = True,
+        signature: bool = False,
+    ) -> str:
+        """[audio] Convert text to speech with fallback (pyttsx3 -> gtts -> elevenlabs)."""
+        from scitex.audio._mcp.handlers import speak_handler
+
+        result = await speak_handler(
+            text=text,
+            backend=backend,
+            voice=voice,
+            rate=rate,
+            speed=speed,
+            play=play,
+            save=save,
+            fallback=fallback,
+            agent_id=agent_id,
+            wait=wait,
+            signature=signature,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_generate_audio(
+        text: str,
+        backend: Optional[str] = "gtts",
+        voice: Optional[str] = None,
+        output_path: Optional[str] = None,
+        return_base64: bool = False,
+    ) -> str:
+        """[audio] Generate speech audio file without playing."""
+        from scitex.audio._mcp.handlers import generate_audio_handler
+
+        result = await generate_audio_handler(
+            text=text,
+            backend=backend,
+            voice=voice,
+            output_path=output_path,
+            return_base64=return_base64,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_list_backends() -> str:
+        """[audio] List available TTS backends and their status."""
+        from scitex.audio._mcp.handlers import list_backends_handler
+
+        result = await list_backends_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_list_voices(backend: str = "gtts") -> str:
+        """[audio] List available voices for a backend."""
+        from scitex.audio._mcp.handlers import list_voices_handler
+
+        result = await list_voices_handler(backend=backend)
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_play_audio(path: str) -> str:
+        """[audio] Play an audio file."""
+        from scitex.audio._mcp.handlers import play_audio_handler
+
+        result = await play_audio_handler(path=path)
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_list_audio_files(limit: int = 20) -> str:
+        """[audio] List generated audio files."""
+        from scitex.audio._mcp.handlers import list_audio_files_handler
+
+        result = await list_audio_files_handler(limit=limit)
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_clear_audio_cache(max_age_hours: float = 24) -> str:
+        """[audio] Clear generated audio files."""
+        from scitex.audio._mcp.handlers import clear_audio_cache_handler
+
+        result = await clear_audio_cache_handler(max_age_hours=max_age_hours)
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_check_audio_status() -> str:
+        """[audio] Check WSL audio connectivity and available playback methods."""
+        from scitex.audio._mcp.handlers import check_audio_status_handler
+
+        result = await check_audio_status_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_speech_queue_status() -> str:
+        """[audio] Get the current speech queue status."""
+        from scitex.audio._mcp.handlers import speech_queue_status_handler
+
+        result = await speech_queue_status_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_announce_context(include_full_path: bool = False) -> str:
+        """[audio] Announce current working directory and git branch."""
+        from scitex.audio._mcp.handlers import announce_context_handler
+
+        result = await announce_context_handler(include_full_path=include_full_path)
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_speak_local(
+        text: str,
+        backend: Optional[str] = None,
+        voice: Optional[str] = None,
+        rate: int = 150,
+        speed: float = 1.5,
+        play: bool = True,
+        save: bool = False,
+        fallback: bool = True,
+        agent_id: Optional[str] = None,
+    ) -> str:
+        """[audio] Convert text to speech on the LOCAL/SERVER machine.
+
+        Use when running Claude Code directly on your local machine.
+        Audio plays where MCP server runs.
+        """
+        from scitex.audio._mcp.speak_handlers import speak_local_handler
+
+        result = await speak_local_handler(
+            text=text,
+            backend=backend,
+            voice=voice,
+            rate=rate,
+            speed=speed,
+            play=play,
+            save=save,
+            fallback=fallback,
+            agent_id=agent_id,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def audio_speak_relay(
+        text: str,
+        backend: Optional[str] = None,
+        voice: Optional[str] = None,
+        rate: int = 150,
+        speed: float = 1.5,
+        play: bool = True,
+        save: bool = False,
+        fallback: bool = True,
+        agent_id: Optional[str] = None,
+    ) -> str:
+        """[audio] Convert text to speech via RELAY server (remote playback).
+
+        Use when running on remote server (NAS) and want audio on your
+        local machine. Returns error with setup instructions if unavailable.
+        """
+        from scitex.audio._mcp.speak_handlers import speak_relay_handler
+
+        result = await speak_relay_handler(
+            text=text,
+            backend=backend,
+            voice=voice,
+            rate=rate,
+            speed=speed,
+            play=play,
+            save=save,
+            fallback=fallback,
+            agent_id=agent_id,
+        )
+        return _json(result)
+
+
+# EOF

scitex/_mcp_tools/canvas.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-15
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/canvas.py
+"""Canvas module tools for FastMCP unified server."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+
+def _json(data: dict) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+def register_canvas_tools(mcp) -> None:
+    """Register canvas tools with FastMCP server."""
+
+    @mcp.tool()
+    async def canvas_create_canvas(
+        parent_dir: str,
+        canvas_name: str,
+        width_mm: float = 180,
+        height_mm: float = 120,
+    ) -> str:
+        """[canvas] Create a new paper figure canvas workspace."""
+        from scitex.canvas._mcp.handlers import create_canvas_handler
+
+        result = await create_canvas_handler(
+            parent_dir=parent_dir,
+            canvas_name=canvas_name,
+            width_mm=width_mm,
+            height_mm=height_mm,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def canvas_add_panel(
+        parent_dir: str,
+        canvas_name: str,
+        panel_name: str,
+        source: str,
+        x_mm: float = 0,
+        y_mm: float = 0,
+        width_mm: float = 50,
+        height_mm: float = 50,
+        label: Optional[str] = None,
+    ) -> str:
+        """[canvas] Add a panel to an existing canvas from an image or plot."""
+        from scitex.canvas._mcp.handlers import add_panel_handler
+
+        result = await add_panel_handler(
+            parent_dir=parent_dir,
+            canvas_name=canvas_name,
+            panel_name=panel_name,
+            source=source,
+            x_mm=x_mm,
+            y_mm=y_mm,
+            width_mm=width_mm,
+            height_mm=height_mm,
+            label=label,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def canvas_list_panels(parent_dir: str, canvas_name: str) -> str:
+        """[canvas] List all panels in a canvas with their properties."""
+        from scitex.canvas._mcp.handlers import list_panels_handler
+
+        result = await list_panels_handler(
+            parent_dir=parent_dir, canvas_name=canvas_name
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def canvas_remove_panel(
+        parent_dir: str, canvas_name: str, panel_name: str
+    ) -> str:
+        """[canvas] Remove a panel from a canvas."""
+        from scitex.canvas._mcp.handlers import remove_panel_handler
+
+        result = await remove_panel_handler(
+            parent_dir=parent_dir,
+            canvas_name=canvas_name,
+            panel_name=panel_name,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def canvas_export_canvas(
+        parent_dir: str,
+        canvas_name: str,
+        output_path: Optional[str] = None,
+        format: Optional[str] = None,
+        dpi: int = 300,
+    ) -> str:
+        """[canvas] Export/render canvas to PNG, PDF, or SVG format."""
+        from scitex.canvas._mcp.handlers import export_canvas_handler
+
+        result = await export_canvas_handler(
+            parent_dir=parent_dir,
+            canvas_name=canvas_name,
+            output_path=output_path,
+            format=format,
+            dpi=dpi,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def canvas_list_canvases(parent_dir: str) -> str:
+        """[canvas] List all canvases in a directory."""
+        from scitex.canvas._mcp.handlers import list_canvases_handler
+
+        result = await list_canvases_handler(parent_dir=parent_dir)
+        return _json(result)
+
+    @mcp.tool()
+    async def canvas_canvas_exists(parent_dir: str, canvas_name: str) -> str:
+        """[canvas] Check if a canvas exists."""
+        from scitex.canvas._mcp.handlers import canvas_exists_handler
+
+        result = await canvas_exists_handler(
+            parent_dir=parent_dir, canvas_name=canvas_name
+        )
+        return _json(result)
+
+
+# EOF

scitex/_mcp_tools/capture.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-15
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/capture.py
+"""Capture module tools for FastMCP unified server."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+
+def _json(data: dict) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+def register_capture_tools(mcp) -> None:
+    """Register capture tools with FastMCP server."""
+
+    @mcp.tool()
+    async def capture_capture_screenshot(
+        monitor_id: int = 0,
+        all: bool = False,
+        quality: int = 85,
+        message: Optional[str] = None,
+        return_base64: bool = False,
+        url: Optional[str] = None,
+        app: Optional[str] = None,
+    ) -> str:
+        """[capture] Capture screenshot - monitor, window, browser, or everything."""
+        from scitex.capture._mcp.handlers import capture_screenshot_handler
+
+        result = await capture_screenshot_handler(
+            monitor_id=monitor_id,
+            all=all,
+            quality=quality,
+            message=message,
+            return_base64=return_base64,
+            url=url,
+            app=app,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_start_monitoring(
+        interval: float = 1.0,
+        quality: int = 60,
+        monitor_id: int = 0,
+        capture_all: bool = False,
+        output_dir: Optional[str] = None,
+        verbose: bool = True,
+    ) -> str:
+        """[capture] Start continuous screenshot monitoring."""
+        from scitex.capture._mcp.handlers import start_monitoring_handler
+
+        result = await start_monitoring_handler(
+            interval=interval,
+            quality=quality,
+            monitor_id=monitor_id,
+            capture_all=capture_all,
+            output_dir=output_dir,
+            verbose=verbose,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_stop_monitoring() -> str:
+        """[capture] Stop continuous screenshot monitoring."""
+        from scitex.capture._mcp.handlers import stop_monitoring_handler
+
+        result = await stop_monitoring_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_get_monitoring_status() -> str:
+        """[capture] Get current monitoring status and statistics."""
+        from scitex.capture._mcp.handlers import get_monitoring_status_handler
+
+        result = await get_monitoring_status_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_analyze_screenshot(path: str) -> str:
+        """[capture] Analyze a screenshot for error indicators."""
+        from scitex.capture._mcp.handlers import analyze_screenshot_handler
+
+        result = await analyze_screenshot_handler(path=path)
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_list_recent_screenshots(
+        limit: int = 10, category: str = "all"
+    ) -> str:
+        """[capture] List recent screenshots from cache."""
+        from scitex.capture._mcp.handlers import list_recent_screenshots_handler
+
+        result = await list_recent_screenshots_handler(limit=limit, category=category)
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_clear_cache(
+        clear_all: bool = False, max_size_gb: float = 1.0
+    ) -> str:
+        """[capture] Clear screenshot cache or manage cache size."""
+        from scitex.capture._mcp.handlers import clear_cache_handler
+
+        result = await clear_cache_handler(clear_all=clear_all, max_size_gb=max_size_gb)
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_create_gif(
+        session_id: Optional[str] = None,
+        image_paths: Optional[list] = None,
+        pattern: Optional[str] = None,
+        output_path: Optional[str] = None,
+        duration: float = 0.5,
+        max_frames: Optional[int] = None,
+        optimize: bool = True,
+    ) -> str:
+        """[capture] Create an animated GIF from screenshots."""
+        from scitex.capture._mcp.handlers import create_gif_handler
+
+        result = await create_gif_handler(
+            session_id=session_id,
+            image_paths=image_paths,
+            pattern=pattern,
+            output_path=output_path,
+            duration=duration,
+            max_frames=max_frames,
+            optimize=optimize,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_list_sessions(limit: int = 10) -> str:
+        """[capture] List available monitoring sessions."""
+        from scitex.capture._mcp.handlers import list_sessions_handler
+
+        result = await list_sessions_handler(limit=limit)
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_get_info() -> str:
+        """[capture] Enumerate monitors, desktops, and windows."""
+        from scitex.capture._mcp.handlers import get_info_handler
+
+        result = await get_info_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_list_windows() -> str:
+        """[capture] List all visible windows with handles."""
+        from scitex.capture._mcp.handlers import list_windows_handler
+
+        result = await list_windows_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def capture_capture_window(
+        window_handle: int,
+        output_path: Optional[str] = None,
+        quality: int = 85,
+    ) -> str:
+        """[capture] Capture a specific window by its handle."""
+        from scitex.capture._mcp.handlers import capture_window_handler
+
+        result = await capture_window_handler(
+            window_handle=window_handle,
+            output_path=output_path,
+            quality=quality,
+        )
+        return _json(result)
+
+
+# EOF

scitex/_mcp_tools/diagram.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-24
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/diagram.py
+"""Diagram module tools for FastMCP unified server.
+
+Delegates entirely to figrecipe's diagram MCP tools.
+figrecipe is the single source of truth.
+"""
+
+from __future__ import annotations
+
+
+def register_diagram_tools(mcp) -> None:
+    """Register diagram tools by delegating to figrecipe."""
+    from figrecipe._mcp._diagram_tools import (
+        register_diagram_tools as register_figrecipe_diagram_tools,
+    )
+
+    register_figrecipe_diagram_tools(mcp)
+
+
+# EOF