genxai-framework 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

cli/commands/__init__.py

@@ -2,5 +2,7 @@
 
 from cli.commands.tool import tool
 from cli.commands.metrics import metrics
+from cli.commands.connector import connector
+from cli.commands.workflow import workflow
 
-__all__ = ["tool", "metrics"]
+__all__ = ["tool", "metrics", "connector", "workflow"]

cli/commands/connector.py

@@ -0,0 +1,309 @@
+"""Connector management CLI commands."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Dict, Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from genxai.connectors import (
+    Connector,
+    KafkaConnector,
+    SQSConnector,
+    PostgresCDCConnector,
+    WebhookConnector,
+    SlackConnector,
+    GitHubConnector,
+    NotionConnector,
+    JiraConnector,
+    GoogleWorkspaceConnector,
+)
+from genxai.connectors.config_store import ConnectorConfigEntry, ConnectorConfigStore
+
+console = Console()
+
+
+CONNECTOR_CATALOG: Dict[str, Dict[str, Any]] = {
+    "kafka": {
+        "class": KafkaConnector,
+        "required": ["topic", "bootstrap_servers"],
+        "description": "Kafka consumer connector",
+    },
+    "sqs": {
+        "class": SQSConnector,
+        "required": ["queue_url"],
+        "description": "AWS SQS connector",
+    },
+    "postgres_cdc": {
+        "class": PostgresCDCConnector,
+        "required": ["dsn"],
+        "description": "Postgres CDC connector",
+    },
+    "webhook": {
+        "class": WebhookConnector,
+        "required": [],
+        "description": "Inbound webhook connector",
+    },
+    "slack": {
+        "class": SlackConnector,
+        "required": ["bot_token"],
+        "description": "Slack Web API connector",
+    },
+    "github": {
+        "class": GitHubConnector,
+        "required": ["token"],
+        "description": "GitHub REST API connector",
+    },
+    "notion": {
+        "class": NotionConnector,
+        "required": ["token"],
+        "description": "Notion API connector",
+    },
+    "jira": {
+        "class": JiraConnector,
+        "required": ["email", "api_token", "base_url"],
+        "description": "Jira Cloud REST API connector",
+    },
+    "google_workspace": {
+        "class": GoogleWorkspaceConnector,
+        "required": ["access_token"],
+        "description": "Google Workspace APIs connector",
+    },
+}
+
+
+@click.group()
+def connector() -> None:
+    """Manage GenXAI connectors."""
+    pass
+
+
+@connector.command("list")
+@click.option("--format", "output_format", type=click.Choice(["table", "json"]), default="table")
+def list_connectors(output_format: str) -> None:
+    """List available connector types."""
+    if output_format == "json":
+        payload = {
+            name: {
+                "required": meta["required"],
+                "description": meta["description"],
+            }
+            for name, meta in CONNECTOR_CATALOG.items()
+        }
+        click.echo(json.dumps(payload, indent=2))
+        return
+
+    table = Table(title="GenXAI Connectors")
+    table.add_column("Type", style="cyan")
+    table.add_column("Required Fields", style="green")
+    table.add_column("Description", style="white")
+    for name, meta in CONNECTOR_CATALOG.items():
+        table.add_row(name, ", ".join(meta["required"]) or "(none)", meta["description"])
+    console.print(table)
+
+
+@connector.command("validate")
+@click.option("--type", "connector_type", required=True, help="Connector type")
+@click.option("--connector-id", default="connector", show_default=True)
+@click.option("--config", help="JSON config payload for the connector")
+@click.option("--config-name", help="Use a saved connector config")
+def validate(
+    connector_type: str,
+    connector_id: str,
+    config: Optional[str],
+    config_name: Optional[str],
+) -> None:
+    """Validate connector configuration without starting it."""
+    connector_meta = CONNECTOR_CATALOG.get(connector_type)
+    if not connector_meta:
+        raise click.ClickException(
+            f"Unknown connector type '{connector_type}'. Use 'genxai connector list' to see options."
+        )
+
+    config_data = _load_config(config, config_name)
+    missing = [field for field in connector_meta["required"] if field not in config_data]
+    if missing:
+        raise click.ClickException(f"Missing required fields: {', '.join(missing)}")
+
+    connector_instance = _build_connector(connector_id, connector_meta["class"], config_data)
+    try:
+        asyncio.run(connector_instance.validate_config())
+        console.print("[green]✓ Connector configuration valid[/green]")
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+@connector.command("start")
+@click.option("--type", "connector_type", required=True, help="Connector type")
+@click.option("--connector-id", default="connector", show_default=True)
+@click.option("--config", help="JSON config payload for the connector")
+@click.option("--config-name", help="Use a saved connector config")
+def start(connector_type: str, connector_id: str, config: Optional[str], config_name: Optional[str]) -> None:
+    """Start a connector instance for quick validation."""
+    connector_instance = _build_from_cli(connector_type, connector_id, config, config_name)
+    try:
+        asyncio.run(connector_instance.start())
+        console.print("[green]✓ Connector started[/green]")
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+@connector.command("stop")
+@click.option("--type", "connector_type", required=True, help="Connector type")
+@click.option("--connector-id", default="connector", show_default=True)
+@click.option("--config", help="JSON config payload for the connector")
+@click.option("--config-name", help="Use a saved connector config")
+def stop(connector_type: str, connector_id: str, config: Optional[str], config_name: Optional[str]) -> None:
+    """Stop a connector instance for quick validation."""
+    connector_instance = _build_from_cli(connector_type, connector_id, config, config_name)
+    try:
+        asyncio.run(connector_instance.stop())
+        console.print("[green]✓ Connector stopped[/green]")
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+@connector.command("health")
+@click.option("--type", "connector_type", required=True, help="Connector type")
+@click.option("--connector-id", default="connector", show_default=True)
+@click.option("--config", help="JSON config payload for the connector")
+@click.option("--format", "output_format", type=click.Choice(["json", "table"]), default="json")
+@click.option("--config-name", help="Use a saved connector config")
+def health(
+    connector_type: str,
+    connector_id: str,
+    config: Optional[str],
+    output_format: str,
+    config_name: Optional[str],
+) -> None:
+    """Run a connector health check without starting it."""
+    connector_instance = _build_from_cli(connector_type, connector_id, config, config_name)
+    try:
+        payload = asyncio.run(connector_instance.health_check())
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    if output_format == "json":
+        click.echo(json.dumps(payload, indent=2))
+        return
+
+    table = Table(title="Connector Health")
+    table.add_column("Field", style="cyan")
+    table.add_column("Value", style="white")
+    for key, value in payload.items():
+        table.add_row(str(key), str(value))
+    console.print(table)
+
+
+@connector.command("save")
+@click.option("--name", "config_name", required=True, help="Name for the saved config")
+@click.option("--type", "connector_type", required=True, help="Connector type")
+@click.option("--config", required=True, help="JSON config payload")
+def save(config_name: str, connector_type: str, config: str) -> None:
+    """Save a connector config for reuse."""
+    connector_meta = CONNECTOR_CATALOG.get(connector_type)
+    if not connector_meta:
+        raise click.ClickException(
+            f"Unknown connector type '{connector_type}'. Use 'genxai connector list' to see options."
+        )
+    config_data = _load_config(config, None)
+    missing = [field for field in connector_meta["required"] if field not in config_data]
+    if missing:
+        raise click.ClickException(f"Missing required fields: {', '.join(missing)}")
+
+    store = ConnectorConfigStore()
+    store.save(
+        ConnectorConfigEntry(
+            name=config_name,
+            connector_type=connector_type,
+            config=config_data,
+        )
+    )
+    console.print(f"[green]✓ Saved connector config '{config_name}'[/green]")
+
+
+@connector.command("saved")
+@click.option("--format", "output_format", type=click.Choice(["table", "json"]), default="table")
+def list_saved(output_format: str) -> None:
+    """List saved connector configs."""
+    store = ConnectorConfigStore()
+    entries = store.list()
+    if output_format == "json":
+        payload = {
+            name: {"connector_type": entry.connector_type, "config": entry.config}
+            for name, entry in entries.items()
+        }
+        click.echo(json.dumps(payload, indent=2))
+        return
+
+    table = Table(title="Saved Connector Configs")
+    table.add_column("Name", style="cyan")
+    table.add_column("Type", style="green")
+    table.add_column("Config", style="white")
+    for name, entry in entries.items():
+        table.add_row(name, entry.connector_type, json.dumps(entry.config))
+    console.print(table)
+
+
+@connector.command("remove")
+@click.option("--name", "config_name", required=True, help="Saved config name")
+def remove(config_name: str) -> None:
+    """Remove a saved connector config."""
+    store = ConnectorConfigStore()
+    if not store.delete(config_name):
+        raise click.ClickException(f"Config '{config_name}' not found")
+    console.print(f"[green]✓ Removed connector config '{config_name}'[/green]")
+
+
+@connector.command("keygen")
+def keygen() -> None:
+    """Generate a Fernet key for encrypted connector configs."""
+    try:
+        from cryptography.fernet import Fernet
+    except ImportError as exc:
+        raise click.ClickException(
+            "cryptography is required for key generation. Install with: pip install cryptography"
+        ) from exc
+    key = Fernet.generate_key().decode()
+    click.echo(key)
+
+
+def _build_connector(connector_id: str, connector_class: type[Connector], config: Dict[str, Any]) -> Connector:
+    params = {"connector_id": connector_id, **config}
+    return connector_class(**params)
+
+
+def _build_from_cli(
+    connector_type: str,
+    connector_id: str,
+    config: Optional[str],
+    config_name: Optional[str],
+) -> Connector:
+    connector_meta = CONNECTOR_CATALOG.get(connector_type)
+    if not connector_meta:
+        raise click.ClickException(
+            f"Unknown connector type '{connector_type}'. Use 'genxai connector list' to see options."
+        )
+    config_data = _load_config(config, config_name)
+    missing = [field for field in connector_meta["required"] if field not in config_data]
+    if missing:
+        raise click.ClickException(f"Missing required fields: {', '.join(missing)}")
+    return _build_connector(connector_id, connector_meta["class"], config_data)
+
+
+def _load_config(config: Optional[str], config_name: Optional[str]) -> Dict[str, Any]:
+    if config_name:
+        store = ConnectorConfigStore()
+        entry = store.get(config_name)
+        if not entry:
+            raise click.ClickException(f"Config '{config_name}' not found")
+        return entry.config
+    return json.loads(config) if config else {}
+
+
+if __name__ == "__main__":
+    connector()

cli/commands/workflow.py

@@ -0,0 +1,80 @@
+"""Workflow CLI commands."""
+
+from pathlib import Path
+from typing import Any, Dict
+
+import click
+
+from genxai.core.graph import load_workflow_yaml, register_workflow_agents
+from genxai.core.graph.executor import WorkflowExecutor
+
+
+@click.group()
+def workflow() -> None:
+    """Manage and run workflows."""
+
+
+@workflow.command("run")
+@click.argument("workflow_path", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--input", "input_payload", required=True, help="JSON input payload")
+def run_workflow(workflow_path: Path, input_payload: str) -> None:
+    """Run a workflow from a YAML file."""
+    import json
+
+    try:
+        workflow = load_workflow_yaml(workflow_path)
+    except (ValueError, FileNotFoundError) as exc:
+        raise click.ClickException(str(exc)) from exc
+    register_workflow_agents(workflow)
+
+    nodes = _build_nodes_from_workflow(workflow)
+    edges = _build_edges_from_workflow(workflow)
+
+    executor = WorkflowExecutor()
+    input_data = json.loads(input_payload)
+    shared_memory = workflow.get("memory", {}).get("shared", False)
+
+    result = _run_executor(executor, nodes, edges, input_data, shared_memory=shared_memory)
+    click.echo(json.dumps(result, indent=2))
+
+
+def _build_nodes_from_workflow(workflow: Dict[str, Any]):
+    nodes = workflow.get("graph", {}).get("nodes", [])
+    if not isinstance(nodes, list):
+        raise click.ClickException("workflow.graph.nodes must be a list")
+    return nodes
+
+
+def _build_edges_from_workflow(workflow: Dict[str, Any]):
+    edges = workflow.get("graph", {}).get("edges", [])
+    if not isinstance(edges, list):
+        raise click.ClickException("workflow.graph.edges must be a list")
+    # Map YAML edge keys to executor expectations.
+    return [
+        {
+            "source": edge.get("from"),
+            "target": edge.get("to"),
+            "condition": edge.get("condition"),
+        }
+        for edge in edges
+    ]
+
+
+def _run_executor(
+    executor: WorkflowExecutor,
+    nodes,
+    edges,
+    input_data,
+    shared_memory: bool = False,
+):
+    import asyncio
+
+    async def _execute():
+        return await executor.execute(
+            nodes=nodes,
+            edges=edges,
+            input_data=input_data,
+            shared_memory=shared_memory,
+        )
+
+    return asyncio.run(_execute())

cli/main.py

@@ -1,7 +1,7 @@
 """GenXAI CLI - Main entry point."""
 
 import click
-from cli.commands import tool, metrics
+from cli.commands import tool, metrics, connector, workflow
 from cli.commands.approval import approval
 from cli.commands.audit import audit
 
@@ -19,6 +19,8 @@ def cli():
 # Register command groups
 cli.add_command(tool)
 cli.add_command(metrics)
+cli.add_command(connector)
+cli.add_command(workflow)
 cli.add_command(approval)
 cli.add_command(audit)
 

genxai/__init__.py

@@ -17,6 +17,7 @@ from genxai.core.agent import (
     AgentRuntime,
     AgentType,
 )
+from genxai.agents import AssistantAgent, UserProxyAgent
 from genxai.core.graph import (
     Edge,
     EnhancedGraph,
@@ -27,6 +28,22 @@ from genxai.core.graph import (
     WorkflowExecutor,
     execute_workflow_sync,
 )
+from genxai.flows import (
+    FlowOrchestrator,
+    RoundRobinFlow,
+    SelectorFlow,
+    P2PFlow,
+    ParallelFlow,
+    ConditionalFlow,
+    LoopFlow,
+    RouterFlow,
+    EnsembleVotingFlow,
+    CriticReviewFlow,
+    CoordinatorWorkerFlow,
+    MapReduceFlow,
+    SubworkflowFlow,
+    AuctionFlow,
+)
 from genxai.core.memory.manager import MemorySystem
 from genxai.tools import (
     DynamicTool,
@@ -55,6 +72,8 @@ __all__ = [
     "AgentRegistry",
     "AgentRuntime",
     "AgentType",
+    "AssistantAgent",
+    "UserProxyAgent",
     "Graph",
     "EnhancedGraph",
     "WorkflowExecutor",
@@ -71,6 +90,20 @@ __all__ = [
     "ToolResult",
     "DynamicTool",
     "MemorySystem",
+    "FlowOrchestrator",
+    "RoundRobinFlow",
+    "SelectorFlow",
+    "P2PFlow",
+    "ParallelFlow",
+    "ConditionalFlow",
+    "LoopFlow",
+    "RouterFlow",
+    "EnsembleVotingFlow",
+    "CriticReviewFlow",
+    "CoordinatorWorkerFlow",
+    "MapReduceFlow",
+    "SubworkflowFlow",
+    "AuctionFlow",
     "BaseTrigger",
     "TriggerEvent",
     "TriggerRegistry",

genxai/agents/__init__.py

@@ -0,0 +1,8 @@
+"""Preset agent wrappers and convenience helpers."""
+
+from genxai.agents.presets import AssistantAgent, UserProxyAgent
+
+__all__ = [
+    "AssistantAgent",
+    "UserProxyAgent",
+]

genxai/agents/presets.py

@@ -0,0 +1,53 @@
+"""Preset agent wrappers for convenience usage."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from genxai.core.agent.base import Agent, AgentFactory, AgentType
+
+
+class AssistantAgent(Agent):
+    """Thin wrapper around AgentFactory for assistant-style agents."""
+
+    @classmethod
+    def create(
+        cls,
+        id: str,
+        goal: str,
+        role: str = "Assistant",
+        **kwargs: Any,
+    ) -> Agent:
+        return AgentFactory.create_agent(
+            id=id,
+            role=role,
+            goal=goal,
+            agent_type=kwargs.pop("agent_type", AgentType.DELIBERATIVE),
+            **kwargs,
+        )
+
+
+class UserProxyAgent(Agent):
+    """Thin wrapper for user-proxy style agents.
+
+    This is intended to be paired with a human-input tool and runtime execution.
+    """
+
+    @classmethod
+    def create(
+        cls,
+        id: str,
+        goal: str = "Provide user input",
+        role: str = "User",
+        tools: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> Agent:
+        tool_list = tools or []
+        return AgentFactory.create_agent(
+            id=id,
+            role=role,
+            goal=goal,
+            tools=tool_list,
+            agent_type=kwargs.pop("agent_type", AgentType.REACTIVE),
+            **kwargs,
+        )

genxai/connectors/__init__.py

@@ -6,6 +6,11 @@ from genxai.connectors.webhook import WebhookConnector
 from genxai.connectors.kafka import KafkaConnector
 from genxai.connectors.sqs import SQSConnector
 from genxai.connectors.postgres_cdc import PostgresCDCConnector
+from genxai.connectors.slack import SlackConnector
+from genxai.connectors.github import GitHubConnector
+from genxai.connectors.notion import NotionConnector
+from genxai.connectors.jira import JiraConnector
+from genxai.connectors.google_workspace import GoogleWorkspaceConnector
 
 __all__ = [
     "Connector",
@@ -16,4 +21,9 @@ __all__ = [
     "KafkaConnector",
     "SQSConnector",
     "PostgresCDCConnector",
+    "SlackConnector",
+    "GitHubConnector",
+    "NotionConnector",
+    "JiraConnector",
+    "GoogleWorkspaceConnector",
 ]

genxai/connectors/base.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, UTC
 from enum import Enum
 from typing import Any, Awaitable, Callable, Dict, Optional
 import asyncio
@@ -29,7 +29,7 @@ class ConnectorEvent:
 
     connector_id: str
     payload: Dict[str, Any]
-    timestamp: datetime = field(default_factory=datetime.utcnow)
+    timestamp: datetime = field(default_factory=lambda: datetime.now(UTC))
     metadata: Dict[str, Any] = field(default_factory=dict)
 
 
@@ -106,7 +106,7 @@ class Connector(ABC):
             "lifecycle": self.status.value,
             "last_error": self._last_error,
         }
-        self._last_healthcheck = datetime.utcnow().isoformat()
+        self._last_healthcheck = datetime.now(UTC).isoformat()
         return payload
 
     async def validate_config(self) -> None:

genxai/connectors/config_store.py

@@ -0,0 +1,106 @@
+"""Connector configuration persistence helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+import json
+import os
+
+
+@dataclass
+class ConnectorConfigEntry:
+    name: str
+    connector_type: str
+    config: Dict[str, Any]
+
+
+class ConnectorConfigStore:
+    """Persist connector configurations as JSON on disk.
+
+    Supports optional encryption when a key is provided via the
+    `GENXAI_CONNECTOR_CONFIG_KEY` environment variable or `encryption_key`.
+    """
+
+    def __init__(self, path: Optional[Path] = None, encryption_key: Optional[str] = None) -> None:
+        self.path = path or Path(".genxai/connectors.json")
+        self.encryption_key = encryption_key or os.getenv("GENXAI_CONNECTOR_CONFIG_KEY")
+
+    def list(self) -> Dict[str, ConnectorConfigEntry]:
+        data = self._read_raw()
+        return {
+            name: ConnectorConfigEntry(
+                name=name,
+                connector_type=payload["connector_type"],
+                config=payload.get("config", {}),
+            )
+            for name, payload in data.items()
+        }
+
+    def get(self, name: str) -> Optional[ConnectorConfigEntry]:
+        data = self._read_raw()
+        payload = data.get(name)
+        if not payload:
+            return None
+        return ConnectorConfigEntry(
+            name=name,
+            connector_type=payload["connector_type"],
+            config=payload.get("config", {}),
+        )
+
+    def save(self, entry: ConnectorConfigEntry) -> None:
+        data = self._read_raw()
+        data[entry.name] = {
+            "connector_type": entry.connector_type,
+            "config": entry.config,
+        }
+        self._write_raw(data)
+
+    def delete(self, name: str) -> bool:
+        data = self._read_raw()
+        if name not in data:
+            return False
+        data.pop(name)
+        self._write_raw(data)
+        return True
+
+    def _read_raw(self) -> Dict[str, Any]:
+        if not self.path.exists():
+            return {}
+        raw = json.loads(self.path.read_text())
+        if isinstance(raw, dict) and raw.get("encrypted"):
+            payload = raw.get("payload")
+            if not payload:
+                raise ValueError("Encrypted connector config missing payload")
+            return json.loads(self._decrypt(payload))
+        return raw
+
+    def _write_raw(self, data: Dict[str, Any]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        if self.encryption_key:
+            encrypted = self._encrypt(json.dumps(data))
+            payload = {"encrypted": True, "payload": encrypted}
+            self.path.write_text(json.dumps(payload, indent=2))
+            return
+        self.path.write_text(json.dumps(data, indent=2))
+
+    def _get_fernet(self):
+        if not self.encryption_key:
+            raise ValueError("Encryption key not configured")
+        try:
+            from cryptography.fernet import Fernet
+        except ImportError as exc:
+            raise ImportError(
+                "cryptography is required for encrypted connector configs. "
+                "Install with: pip install cryptography"
+            ) from exc
+        return Fernet(self.encryption_key.encode())
+
+    def _encrypt(self, payload: str) -> str:
+        fernet = self._get_fernet()
+        return fernet.encrypt(payload.encode()).decode()
+
+    def _decrypt(self, payload: str) -> str:
+        fernet = self._get_fernet()
+        return fernet.decrypt(payload.encode()).decode()