wpipe-mcp 0.1.0__py3-none-any.whl

__init__.py

@@ -0,0 +1 @@
+from . import *

wpipe_mcp/__init__.py

@@ -0,0 +1 @@
+from .controller import Basemodel

wpipe_mcp/catalog.py

@@ -0,0 +1,97 @@
+import json
+import urllib.request
+import logging
+
+# Configuración de logging básica
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class StepsCatalog:
+    """
+    Manages the synchronization of available steps from the wisrovi SUITE.
+    Synchronizes from GitHub just like the VS Code extension.
+    """
+    
+    # URLs synchronized with the VS Code extension
+    OFFICIAL_URL = "https://raw.githubusercontent.com/wisrovi/wpipe-steps/001-DEVELOPMENT/steps_catalog.json"
+    COMMUNITY_URL = "https://raw.githubusercontent.com/wisrovi/wpipe-plugins/001-DEVELOPMENT/steps_catalog.json"
+    
+    def __init__(self):
+        self.cached_steps = []
+        self._load_initial_catalog()
+
+    def _fetch_url(self, url: str) -> list:
+        try:
+            req = urllib.request.Request(url, headers={'User-Agent': 'wpipe-mcp'})
+            with urllib.request.urlopen(req, timeout=5) as response:
+                if response.status == 200:
+                    return json.loads(response.read().decode('utf-8'))
+        except Exception as e:
+            logger.warning(f"Failed to fetch catalog from {url}: {e}")
+        return []
+
+    def refresh_catalog(self) -> list:
+        """Fetch latest steps from both official and community repositories."""
+        official = self._fetch_url(self.OFFICIAL_URL)
+        community = self._fetch_url(self.COMMUNITY_URL)
+        
+        # Merge and mark origin
+        all_steps = []
+        for s in official:
+            s['origin'] = 'Official'
+            all_steps.append(s)
+        for s in community:
+            s['origin'] = 'Community'
+            all_steps.append(s)
+            
+        if all_steps:
+            self.cached_steps = all_steps
+            logger.info(f"Catalog refreshed: {len(self.cached_steps)} steps found.")
+        
+        return self.cached_steps
+
+    def search(self, query: str) -> list:
+        """Filters cataloged steps based on a search query keyword."""
+        if not self.cached_steps:
+            self.refresh_catalog()
+            
+        query_lower = query.lower()
+        results = []
+        for step in self.cached_steps:
+            # Match against multiple fields
+            fields = [
+                step.get('name', ''),
+                step.get('func_name', ''),
+                step.get('namespace', ''),
+                step.get('description', ''),
+                step.get('category', '')
+            ]
+            if any(query_lower in str(f).lower() for f in fields):
+                results.append(step)
+        return results
+
+    def _load_initial_catalog(self):
+        """Initial load with hardcoded fallbacks if offline."""
+        self.cached_steps = [
+            {
+                "name": "http_request",
+                "func_name": "HttpRequestStep",
+                "namespace": "wpipe_steps.connectivity.http",
+                "description": "Resilient HTTP client for REST APIs",
+                "category": "Connectivity",
+                "origin": "Official"
+            },
+            {
+                "name": "postgresql_query",
+                "func_name": "PostgreSQLQueryStep",
+                "namespace": "wpipe_steps.databases.postgresql",
+                "description": "Database worker with connection pooling",
+                "category": "Databases",
+                "origin": "Official"
+            }
+        ]
+        # Attempt an immediate refresh
+        try:
+            self.refresh_catalog()
+        except:
+            pass

wpipe_mcp/server.py

@@ -0,0 +1,156 @@
+import os
+import sys
+import argparse
+import subprocess
+import signal
+import json
+import logging
+from mcp.server.fastmcp import FastMCP
+from wpipe_mcp.catalog import StepsCatalog
+from wpipe_mcp.templates import TemplateGenerator
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+logger = logging.getLogger(__name__)
+
+# PID file for background service
+PID_FILE = os.path.expanduser("~/.wpipe_mcp.pid")
+
+# Create the primary FastMCP Server instance
+mcp = FastMCP("wpipe-mcp-server")
+catalog = StepsCatalog()
+
+# --- Tools ---
+
+@mcp.tool()
+def search_wpipe_step(query: str) -> str:
+    """Search for existing pipeline steps in official and community catalogs."""
+    results = catalog.search(query)
+    if not results:
+        return f"No custom step matching '{query}' was found. Recommend building a native WPipe Class-based Step."
+    
+    response = "Found production-ready architectural steps in wisrovi SUITE:\n\n"
+    for s in results:
+        response += f"🚀 [{s.get('origin', 'Unknown')}] {s.get('func_name', s.get('label'))}\n"
+        response += f"   - Description: {s.get('description', 'N/A')}\n"
+        response += f"   - Namespace: {s.get('namespace', 'N/A')}\n\n"
+    return response
+
+@mcp.tool()
+def deploy_wpipe_scaffolding(target_dir: str, project_name: str = "wpipe_project", pipeline_type: str = "standard") -> str:
+    """Deploys a professional WPipe project structure with class-based states."""
+    try:
+        if not os.path.isabs(target_dir):
+            return "Error: target_dir must be an absolute path."
+
+        for folder in TemplateGenerator.get_folders(pipeline_type):
+            os.makedirs(os.path.join(target_dir, folder), exist_ok=True)
+
+        blueprints = TemplateGenerator.get_files_blueprint(pipeline_type, project_name)
+        for rel_path, content in blueprints.items():
+            full_path = os.path.join(target_dir, rel_path)
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, "w", encoding="utf-8") as f:
+                f.write(content)
+
+        return f"Success: WPipe architecture '{project_name}' deployed at {target_dir}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@mcp.tool()
+def get_wpipe_architect_manual() -> str:
+    """Expert manual for building high-performance pipelines (wisrovi standard)."""
+    return (
+        "WPIPE ARCHITECT MANUAL\n"
+        "1. Prefer Class-based States (@step).\n"
+        "2. Use Typed Context (PipelineContext/Pydantic).\n"
+        "3. Apply @to_obj on __call__.\n"
+        "4. Always use tracking_db for forensics."
+    )
+
+# --- CLI Actions ---
+
+def run_stdio():
+    """Runs the MCP server in stdio mode (standard for agents)."""
+    mcp.run(transport="stdio")
+
+def run_sse():
+    """Runs the MCP server in SSE mode."""
+    mcp.run(transport="sse")
+
+def start_background():
+    """Starts the SSE server in the background."""
+    if os.path.exists(PID_FILE):
+        print("Server is already running or PID file exists.")
+        return
+
+    # In a real scenario, we would use a proper daemon library, 
+    # but for simplicity, we use subprocess.
+    proc = subprocess.Popen(
+        [sys.executable, "-m", "wpipe_mcp.server", "run-sse"],
+        stdout=open(os.path.expanduser("~/wpipe_mcp.log"), "a"),
+        stderr=subprocess.STDOUT,
+        preexec_fn=os.setpgrp
+    )
+    with open(PID_FILE, "w") as f:
+        f.write(str(proc.pid))
+    print(f"wpipe-mcp started in background (SSE mode) with PID {proc.pid}")
+
+def stop_background():
+    """Stops the background SSE server."""
+    if not os.path.exists(PID_FILE):
+        print("No background server running.")
+        return
+
+    with open(PID_FILE, "r") as f:
+        pid = int(f.read())
+    
+    try:
+        os.kill(pid, signal.SIGTERM)
+        print(f"Stopped server with PID {pid}")
+    except ProcessLookupError:
+        print("Process not found.")
+    finally:
+        os.remove(PID_FILE)
+
+def print_config():
+    """Prints the JSON configuration for agents."""
+    path = subprocess.check_output(["which", "wpipe-mcp"]).decode().strip()
+    config = {
+        "mcpServers": {
+            "wpipe-mcp": {
+                "command": path,
+                "args": ["run"],
+                "env": {}
+            }
+        }
+    }
+    print(json.dumps(config, indent=2))
+
+# --- Main Entry Point ---
+
+def main():
+    parser = argparse.ArgumentParser(description="wpipe-mcp: WPipe Architect MCP Server")
+    parser.add_argument("command", nargs="?", default="run", 
+                        choices=["run", "run-sse", "start", "stop", "config", "help"],
+                        help="Command to execute (default: run)")
+
+    args = parser.parse_args()
+
+    if args.command == "run":
+        run_stdio()
+    elif args.command == "run-sse":
+        run_sse()
+    elif args.command == "start":
+        start_background()
+    elif args.command == "stop":
+        stop_background()
+    elif args.command == "config":
+        print_config()
+    elif args.command == "help":
+        parser.print_help()
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

wpipe_mcp/templates.py

@@ -0,0 +1,86 @@
+# Advanced scaffolding templates for professional WPipe development
+
+class TemplateGenerator:
+    """Provides professional boilerplate for WPipe projects following wisrovi standards."""
+
+    @staticmethod
+    def get_supported_types() -> list:
+        return ["standard", "ai_vision_mlops"]
+
+    @staticmethod
+    def get_folders(pipeline_type: str) -> list:
+        if pipeline_type == "ai_vision_mlops":
+            return ["config", "src", "src/inference", "src/training", "src/training/tasks", "src/states", "datasets", "tests", ".wpipe"]
+        return ["config", "src", "src/steps", "src/states", "tests", ".wpipe"]
+
+    @staticmethod
+    def get_files_blueprint(pipeline_type: str, project_name: str = "wpipe_project") -> dict:
+        """Returns filenames and their professional template content."""
+        
+        # Professional Class-based State Template
+        state_template = (
+            "from wpipe import step, to_obj, PipelineContext\n"
+            "from pydantic import Field\n"
+            "from typing import Any\n\n"
+            "class MyContext(PipelineContext):\n"
+            "    \"\"\"Typed context for the pipeline.\"\"\"\n"
+            "    data: dict = Field(default_factory=dict)\n"
+            "    status: str = \"init\"\n\n"
+            "@step(\n"
+            "    name=\"process_data\",\n"
+            "    version=\"v1.0\",\n"
+            "    retry_count=3,\n"
+            "    retry_delay=0.1,\n"
+            "    tags=[\"processing\"]\n"
+            ")\n"
+            "class ProcessDataStep:\n"
+            "    \"\"\"Professional class-based step with typed context.\"\"\"\n"
+            "    def __init__(self, config_param: str = \"default\"):\n"
+            "        self.config_param = config_param\n\n"
+            "    @to_obj(MyContext)\n"
+            "    def __call__(self, ctx: MyContext) -> Any:\n"
+            "        # Your logic here\n"
+            "        ctx.status = \"completed\"\n"
+            "        return ctx\n"
+        )
+
+        # Main Pipeline Template
+        pipeline_template = (
+            "import os\n"
+            "from wpipe import Pipeline\n"
+            "from wpipe.exception.api_error import ProcessError\n"
+            "from src.states.process_step import ProcessDataStep\n\n"
+            "def create_pipeline():\n"
+            "    pipeline = Pipeline(\n"
+            "        pipeline_name=\"{name}\",\n"
+            "        tracking_db=\"output/tracking.db\",\n"
+            "        collect_system_metrics=True,\n"
+            "        verbose=True\n"
+            "    )\n\n"
+            "    pipeline.set_steps([\n"
+            "        ProcessDataStep(config_param=\"prod\")\n"
+            "    ])\n"
+            "    return pipeline\n\n"
+            "if __name__ == \"__main__\":\n"
+            "    pipeline = create_pipeline()\n"
+            "    try:\n"
+            "        result = pipeline.run({{\"data\": \"init\"}})\n"
+            "        print(f\"Pipeline completed: {result}\")\n"
+            "    except ProcessError as e:\n"
+            "        print(f\"Pipeline failed: {e}\")\n"
+        ).format(name=project_name)
+
+        blueprints = {
+            "requirements.txt": "wpipe>=1.0.0\nwdecorators>=2.0.0\npydantic>=2.0.0\n",
+            "README.md": f"# {project_name.upper()}\n\nProfessional architecture built with **wpipe**.\n",
+            "src/states/__init__.py": "from .process_step import ProcessDataStep\n",
+            "src/states/process_step.py": state_template,
+            "main.py": pipeline_template,
+            "wpipe.config.json": '{\n  "enableBackupFile": true,\n  "maxSearchFiles": 500\n}\n'
+        }
+
+        if pipeline_type == "ai_vision_mlops":
+            blueprints["requirements.txt"] += "wyolo>=1.0.0\nwtrain>=1.0.0\ncelery>=5.3.0\n"
+            # Add vision specific boilerplate...
+            
+        return blueprints

wpipe_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: wpipe-mcp
+Version: 0.1.0
+Summary: MCP Server for WPipe Architecting
+License-File: LICENSE
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: pydantic>=2.0.0
+Dynamic: license-file

wpipe_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+__init__.py,sha256=ovguP4wzQEDNguczwiZnhMm4dRRVcvnzmHrfQtlRCNQ,15
+wpipe_mcp/__init__.py,sha256=geKbTbFXY0okC9p2MWGvFfrRmGe-_llqb7-7ObnyGuA,34
+wpipe_mcp/catalog.py,sha256=bSjrVq5UyoaiBaiaZGn1ROJKowd_TiyvVRhVVYl-af0,3492
+wpipe_mcp/server.py,sha256=9YpFZJsBZK8Zbwduf_9c2coaGTfIgeZoGqqFBz3ltc8,5138
+wpipe_mcp/templates.py,sha256=1r1agrt5ZNswoo3bkp8ddWxpxuIG1LFy7-NmgeSbGVg,3861
+wpipe_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=4oHDhqFmuRLOBDfP8L1gew89Gb-8jkHEJbUhRLmuuTA,1074
+wpipe_mcp-0.1.0.dist-info/METADATA,sha256=6vjklWfZ-v1tfzG1UXZcAwrnWTK_NpOyBk8QcGISfRE,232
+wpipe_mcp-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wpipe_mcp-0.1.0.dist-info/entry_points.txt,sha256=F4WuKW8SlFB8DwInXIqUJqhTJ55Q8FJ5hN7ocD-1NyI,52
+wpipe_mcp-0.1.0.dist-info/top_level.txt,sha256=rScxF6xYkU7AVI3i6gCdGhkOz_G2jEF-Rhjtzh-uSXE,19
+wpipe_mcp-0.1.0.dist-info/RECORD,,

wpipe_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wpipe_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wpipe-mcp = wpipe_mcp.server:main

wpipe_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 William Rodriguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wpipe_mcp-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+wpipe_mcp