feat: Add Python plugins from AutoMetabuilder + restructure workflow folder

Restructure workflow/ for multi-language plugin support:
- Rename src/ to core/ (engine code: DAG executor, registry, types)
- Create executor/{cpp,python,ts}/ for language-specific runtimes
- Consolidate plugins to plugins/{ts,python}/ by language then category

Add 80+ Python plugins from AutoMetabuilder in 14 categories:
- control: bot control, switch logic, state management
- convert: type conversions (json, boolean, dict, list, number, string)
- core: AI requests, context management, tool calls
- dict: dictionary operations (get, set, keys, values, merge)
- list: list operations (concat, find, sort, slice, filter)
- logic: boolean logic (and, or, xor, equals, comparisons)
- math: arithmetic operations (add, subtract, multiply, power, etc.)
- string: string manipulation (concat, split, replace, format)
- notifications: Slack, Discord integrations
- test: assertion helpers and test suite runner
- tools: file operations, git, docker, testing utilities
- utils: filtering, mapping, reducing, condition branching
- var: variable store operations (get, set, delete, exists)
- web: Flask server, environment variables, JSON handling

Add language executor runtimes:
- TypeScript: direct import execution (default, fast startup)
- Python: child process with JSON stdin/stdout communication
- C++: placeholder for native FFI bindings (Phase 3)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

workflow/plugins/python/notifications/__init__.py

@@ -0,0 +1 @@
+"""Notification plugins: Slack, Discord, and multi-channel notifications."""

workflow/plugins/python/notifications/notifications_all.py

@@ -0,0 +1,33 @@
+"""Workflow plugin: send notification to all channels."""
+import os
+import logging
+
+logger = logging.getLogger("metabuilder.notifications")
+
+
+def run(runtime, inputs):
+    """Send a notification to all configured channels (Slack and Discord).
+
+    Inputs:
+        message: The message to send to all channels
+
+    Returns:
+        dict: Contains success status for all channels
+    """
+    message = inputs.get("message", "")
+
+    # Import sibling plugins
+    from . import notifications_slack, notifications_discord
+
+    # Send to Slack
+    slack_result = notifications_slack.run(runtime, {"message": message})
+
+    # Send to Discord
+    discord_result = notifications_discord.run(runtime, {"message": message})
+
+    return {
+        "success": True,
+        "message": "Notifications sent to all channels",
+        "slack": slack_result,
+        "discord": discord_result
+    }

workflow/plugins/python/notifications/notifications_discord.py

@@ -0,0 +1,67 @@
+"""Workflow plugin: send Discord notification."""
+import os
+import logging
+import asyncio
+
+logger = logging.getLogger("metabuilder.notifications")
+
+
+async def _send_discord_notification_async(message: str, token: str, intents, channel_id: str):
+    """Send Discord notification asynchronously."""
+    import discord
+
+    client = discord.Client(intents=intents)
+
+    @client.event
+    async def on_ready():
+        channel = client.get_channel(int(channel_id))
+        if channel:
+            await channel.send(message)
+            logger.info("Discord notification sent successfully.")
+        await client.close()
+
+    try:
+        await client.start(token)
+    except Exception as e:
+        logger.error(f"Error sending Discord notification: {e}")
+        raise
+
+
+def run(runtime, inputs):
+    """Send a notification to Discord.
+
+    Inputs:
+        message: The message to send
+        channel_id: Optional channel ID (defaults to DISCORD_CHANNEL_ID env var)
+
+    Returns:
+        dict: Contains success status and any error message
+    """
+    message = inputs.get("message", "")
+    channel_id = inputs.get("channel_id") or os.environ.get("DISCORD_CHANNEL_ID")
+
+    token = runtime.context.get("discord_token")
+    intents = runtime.context.get("discord_intents")
+
+    if not token:
+        logger.warning("Discord notification skipped: Discord client not initialized.")
+        return {
+            "success": False,
+            "skipped": True,
+            "error": "Discord client not initialized"
+        }
+
+    if not channel_id:
+        logger.warning("Discord notification skipped: DISCORD_CHANNEL_ID missing.")
+        return {
+            "success": False,
+            "skipped": True,
+            "error": "DISCORD_CHANNEL_ID missing"
+        }
+
+    try:
+        asyncio.run(_send_discord_notification_async(message, token, intents, channel_id))
+        return {"success": True, "message": "Discord notification sent"}
+    except Exception as e:
+        logger.error(f"Error running Discord notification: {e}")
+        return {"success": False, "error": str(e)}

workflow/plugins/python/notifications/notifications_slack.py

@@ -0,0 +1,46 @@
+"""Workflow plugin: send Slack notification."""
+import os
+import logging
+
+logger = logging.getLogger("metabuilder.notifications")
+
+
+def run(runtime, inputs):
+    """Send a notification to Slack.
+
+    Inputs:
+        message: The message to send
+        channel: Optional channel (defaults to SLACK_CHANNEL env var)
+
+    Returns:
+        dict: Contains success status and any error message
+    """
+    message = inputs.get("message", "")
+    channel = inputs.get("channel") or os.environ.get("SLACK_CHANNEL")
+
+    client = runtime.context.get("slack_client")
+
+    if not client:
+        logger.warning("Slack notification skipped: Slack client not initialized.")
+        return {
+            "success": False,
+            "skipped": True,
+            "error": "Slack client not initialized"
+        }
+
+    if not channel:
+        logger.warning("Slack notification skipped: SLACK_CHANNEL missing.")
+        return {
+            "success": False,
+            "skipped": True,
+            "error": "SLACK_CHANNEL missing"
+        }
+
+    try:
+        from slack_sdk.errors import SlackApiError
+        client.chat_postMessage(channel=channel, text=message)
+        logger.info("Slack notification sent successfully.")
+        return {"success": True, "message": "Slack notification sent"}
+    except SlackApiError as e:
+        logger.error(f"Error sending Slack notification: {e}")
+        return {"success": False, "error": str(e)}