@mamdouh-aboammar/agentic-workflow 1.2.0

package/core/engine_py/runner.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+runner.py — CLI entry point for Python Agentic Engine.
+"""
+
+import os
+import sys
+import asyncio
+
+# Ensure project root is on sys.path
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
+if root_dir not in sys.path:
+    sys.path.insert(0, root_dir)
+
+from core.engine_py.models import (
+    WorkflowDefinition, StageDefinition, TaskDefinition, AgentRole
+)
+from core.engine_py.queue import InMemoryTaskQueue
+from core.engine_py.event_bus import AsyncEventBus
+from core.engine_py.verification_controller import VerificationController
+from core.engine_py.system_workers import SystemWorker
+from core.engine_py.agent_worker import AgentWorker
+from core.engine_py.executor import AgenticExecutor
+
+
+async def main():
+    project_dir = os.getcwd()
+    print("🚀 [engine-py] Starting Event-Driven Agentic Engine (Python AsyncIO)...")
+
+    wf_def = WorkflowDefinition(
+        name="autonomous_agentic_pipeline",
+        version="1.0.0",
+        stages=[
+            StageDefinition(
+                id="stage_01_research",
+                name="Stage 1: Research",
+                tasks=[
+                    TaskDefinition(
+                        id="task_research_01",
+                        name="Analyze System Architecture and Dependencies",
+                        type="agent.task",
+                        role=AgentRole.RESEARCHER,
+                        deliverable_path="docs/research_findings.md",
+                        criteria=["Analyze architecture patterns", "Establish baseline"]
+                    )
+                ]
+            ),
+            StageDefinition(
+                id="stage_02_planning",
+                name="Stage 2: Planning",
+                tasks=[
+                    TaskDefinition(
+                        id="task_plan_approval",
+                        name="Autopilot Plan Approval",
+                        type="agent.human",
+                        role=AgentRole.ORCHESTRATOR
+                    )
+                ]
+            ),
+            StageDefinition(
+                id="stage_03_implementation",
+                name="Stage 3: Implementation",
+                tasks=[
+                    TaskDefinition(
+                        id="task_code_impl",
+                        name="Implement Core Production Logic",
+                        type="agent.task",
+                        role=AgentRole.ENGINEER,
+                        deliverable_path="docs/implementation_summary.md",
+                        criteria=["Pass unit tests", "Generate comprehensive documentation"]
+                    ),
+                    TaskDefinition(
+                        id="task_review_01",
+                        name="Adversarial Code & Fact-Check Review",
+                        type="agent.review",
+                        role=AgentRole.REVIEWER,
+                        deliverable_path="review-logs/step-3-review.md",
+                        criteria=["Zero critical vulnerabilities"]
+                    )
+                ]
+            )
+        ]
+    )
+
+    queue = InMemoryTaskQueue()
+    ledger_path = os.path.join(project_dir, "ledger.jsonl")
+    event_bus = AsyncEventBus(ledger_path=ledger_path)
+    verifier = VerificationController(project_dir=project_dir)
+
+    sys_worker = SystemWorker(worker_id="sys_worker_py", queue=queue, event_bus=event_bus, verification_controller=verifier)
+    agent_worker = AgentWorker(worker_id="agent_worker_py", queue=queue, event_bus=event_bus, verification_controller=verifier, project_dir=project_dir)
+
+    executor = AgenticExecutor(
+        workflow_def=wf_def,
+        queue=queue,
+        event_bus=event_bus,
+        project_dir=project_dir,
+        sot_filename="state.yaml"
+    )
+
+    print(f"⚡ Trace ID: {executor.instance.trace_id}")
+    print(f"⚡ Workflow ID: {executor.instance.workflow_id}")
+    print(f"⚡ SOT Path: {executor.sot_path}")
+
+    success = await executor.run_until_complete(workers=[sys_worker, agent_worker], poll_interval=0.02, max_iterations=50)
+
+    if success:
+        print("\n🎉 [engine-py] Workflow Completed Successfully with All Gates Verified!")
+        sys.exit(0)
+    else:
+        print("\n❌ [engine-py] Workflow execution halted or failed gates.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/core/engine_py/system_workers.py

@@ -0,0 +1,70 @@
+"""
+system_workers.py — Built-in System Task Workers.
+
+Implements handlers for:
+- system.code: executes inline Python or shell code
+- system.wait: timer delays or external signal pauses
+- system.switch: evaluates dynamic conditional branching
+- system.transform: data projection and key transformation
+"""
+
+import os
+import sys
+import asyncio
+from typing import Dict, Any, List
+
+from core.engine_py.models import TaskInstance
+from core.engine_py.worker import BaseWorker
+
+
+class SystemWorker(BaseWorker):
+    """Worker handling core system task execution without external AI dependencies."""
+
+    def __init__(self, worker_id: str, queue, event_bus, verification_controller=None):
+        super().__init__(
+            worker_id=worker_id,
+            task_types=["system.code", "system.wait", "system.switch", "system.transform"],
+            queue=queue,
+            event_bus=event_bus,
+            verification_controller=verification_controller
+        )
+
+    async def execute_task(self, task: TaskInstance) -> Dict[str, Any]:
+        task_type = task.task_def.type
+
+        if task_type == "system.code":
+            return await self._execute_code(task)
+        elif task_type == "system.wait":
+            return await self._execute_wait(task)
+        elif task_type == "system.switch":
+            return await self._execute_switch(task)
+        elif task_type == "system.transform":
+            return await self._execute_transform(task)
+        else:
+            raise ValueError(f"Unsupported system task type: {task_type}")
+
+    async def _execute_code(self, task: TaskInstance) -> Dict[str, Any]:
+        code = task.task_def.input_parameters.get("code", "")
+        # Safe evaluation of deterministic expressions
+        local_scope: Dict[str, Any] = {"inputs": task.input_data, "result": None}
+        exec(code, {}, local_scope)
+        return {"result": local_scope.get("result", "COMPLETED")}
+
+    async def _execute_wait(self, task: TaskInstance) -> Dict[str, Any]:
+        duration = float(task.task_def.input_parameters.get("seconds", 1.0))
+        await asyncio.sleep(min(duration, 10.0))  # Capped for safety in test run
+        return {"waited_seconds": duration}
+
+    async def _execute_switch(self, task: TaskInstance) -> Dict[str, Any]:
+        condition_key = task.task_def.input_parameters.get("key", "status")
+        val = task.input_data.get(condition_key)
+        branches = task.task_def.branches
+        chosen_branch = branches.get(str(val), branches.get("default", "default_branch"))
+        return {"selected_branch": chosen_branch}
+
+    async def _execute_transform(self, task: TaskInstance) -> Dict[str, Any]:
+        mapping = task.task_def.input_parameters.get("mapping", {})
+        transformed = {}
+        for out_key, in_path in mapping.items():
+            transformed[out_key] = task.input_data.get(in_path)
+        return transformed