kailash 0.1.5__tar.gz → 0.2.0__tar.gz

{kailash-0.1.5/src/kailash.egg-info → kailash-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.1.5
+Version: 0.2.0
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -47,6 +47,13 @@ Requires-Dist: pytest-asyncio>=1.0.0
 Requires-Dist: pre-commit>=4.2.0
 Requires-Dist: twine>=6.1.0
 Requires-Dist: ollama>=0.5.1
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: python-jose>=3.5.0
+Requires-Dist: pytest-xdist>=3.6.0
+Requires-Dist: pytest-timeout>=2.3.0
+Requires-Dist: pytest-split>=0.9.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=3.0; extra == "dev"
@@ -66,7 +73,7 @@ Dynamic: requires-python
   <a href="https://pepy.tech/project/kailash"><img src="https://static.pepy.tech/badge/kailash" alt="Downloads"></a>
   <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="MIT License">
   <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
-  <img src="https://img.shields.io/badge/tests-753%20passing-brightgreen.svg" alt="Tests: 753 passing">
+  <img src="https://img.shields.io/badge/tests-734%20passing-brightgreen.svg" alt="Tests: 734 passing">
   <img src="https://img.shields.io/badge/coverage-100%25-brightgreen.svg" alt="Coverage: 100%">
 </p>
 
@@ -94,6 +101,11 @@ Dynamic: requires-python
 - 🚪 **Multi-Workflow Gateway**: Manage multiple workflows through unified API with MCP integration
 - 🤖 **Self-Organizing Agents**: Autonomous agent pools with intelligent team formation and convergence detection
 - 🧠 **Agent-to-Agent Communication**: Shared memory pools and intelligent caching for coordinated multi-agent systems
+- 🔒 **Production Security**: Comprehensive security framework with path traversal prevention, code sandboxing, and audit logging
+- 🎨 **Visual Workflow Builder**: Kailash Workflow Studio - drag-and-drop interface for creating and managing workflows (coming soon)
+- 🔁 **Cyclic Workflows (v0.2.0)**: Universal Hybrid Cyclic Graph Architecture with 30,000+ iterations/second performance
+- 🛠️ **Developer Tools**: CycleAnalyzer, CycleDebugger, CycleProfiler for production-ready cyclic workflows
+- 📈 **High Performance**: Optimized execution engine supporting 100,000+ iteration workflows
 
 ## 🎯 Who Is This For?
 
@@ -278,6 +290,141 @@ results, run_id = runtime.execute(workflow)
 print("RAG Response:", results["llm_agent"]["response"])
 ```
 
+### Cyclic Workflows - Iterative Processing with Convergence
+
+Build workflows that iterate until a condition is met, perfect for optimization, retries, and ML training:
+
+```python
+from kailash.workflow import Workflow
+from kailash.nodes.base_cycle_aware import CycleAwareNode
+from kailash.nodes.base import NodeParameter
+from kailash.runtime.local import LocalRuntime
+from typing import Any, Dict
+
+# Create a custom cycle-aware node for data quality improvement
+class DataQualityImproverNode(CycleAwareNode):
+    def get_parameters(self) -> Dict[str, NodeParameter]:
+        return {
+            "data": NodeParameter(name="data", type=list, required=True),
+            "target_quality": NodeParameter(name="target_quality", type=float, required=False, default=0.95)
+        }
+
+    def run(self, context: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        """Iteratively improve data quality."""
+        data = kwargs["data"]
+        target_quality = kwargs.get("target_quality", 0.95)
+
+        # Get current iteration and previous state
+        iteration = self.get_iteration(context)
+        prev_state = self.get_previous_state(context)
+
+        # Calculate current quality
+        quality = prev_state.get("quality", 0.5) + 0.1  # Improve by 10% each iteration
+        quality = min(quality, 1.0)
+
+        # Process data (simplified)
+        processed_data = [item for item in data if item is not None]
+
+        # Track quality history
+        quality_history = self.accumulate_values(context, "quality_history", quality, max_history=10)
+
+        # Detect convergence trend
+        trend = self.detect_convergence_trend(context, "quality_history", window_size=5)
+        converged = quality >= target_quality or (trend and trend["slope"] < 0.01)
+
+        # Log progress
+        self.log_cycle_info(context, f"Iteration {iteration}: Quality={quality:.2%}")
+
+        # Save state for next iteration
+        self.set_cycle_state({"quality": quality, "processed_count": len(processed_data)})
+
+        return {
+            "data": processed_data,
+            "quality": quality,
+            "converged": converged,
+            "iteration": iteration,
+            "history": quality_history
+        }
+
+# Build cyclic workflow
+workflow = Workflow("quality_improvement", "Iterative Data Quality")
+workflow.add_node("improver", DataQualityImproverNode())
+
+# Create a cycle - node connects to itself!
+workflow.connect("improver", "improver",
+                 mapping={"data": "data"},  # Pass data to next iteration
+                 cycle=True,  # This is a cycle
+                 max_iterations=20,  # Safety limit
+                 convergence_check="converged == True")  # Stop condition
+
+# Execute with automatic iteration management
+runtime = LocalRuntime()
+results, run_id = runtime.execute(workflow, parameters={
+    "improver": {
+        "data": [1, None, 3, None, 5, 6, None, 8, 9, 10],
+        "target_quality": 0.9
+    }
+})
+
+print(f"Converged after {results['improver']['iteration']} iterations")
+print(f"Final quality: {results['improver']['quality']:.2%}")
+print(f"Quality history: {results['improver']['history']}")
+```
+
+### NEW in v0.2.0: CycleBuilder API
+
+The new CycleBuilder API provides a fluent interface for creating cyclic workflows:
+
+```python
+# Modern approach with CycleBuilder
+workflow.create_cycle("optimization_loop")
+    .connect("gradient", "optimizer")
+    .connect("optimizer", "evaluator")
+    .connect("evaluator", "gradient")
+    .max_iterations(100)
+    .converge_when("loss < 0.01")
+    .early_stop_when("gradient_norm < 1e-6")
+    .checkpoint_every(10)
+    .build()
+
+# Developer tools for production workflows
+from kailash.workflow import CycleAnalyzer, CycleDebugger, CycleProfiler
+
+# Analyze cycle patterns
+analyzer = CycleAnalyzer(workflow)
+report = analyzer.analyze()
+print(f"Found {len(report.cycles)} cycles")
+print(f"Max depth: {report.max_cycle_depth}")
+
+# Debug with breakpoints
+debugger = CycleDebugger(workflow)
+debugger.set_breakpoint("optimizer", iteration=50)
+debugger.set_trace("gradient_norm", lambda x: x < 0.001)
+
+# Profile performance
+profiler = CycleProfiler(workflow)
+profile_data = profiler.profile(runtime, parameters)
+print(f"Bottleneck: {profile_data.bottleneck_node}")
+print(f"Iterations/sec: {profile_data.iterations_per_second}")
+```
+
+#### Cyclic Workflow Features
+
+- **Built-in Iteration Management**: No manual loops or recursion needed
+- **State Persistence**: Maintain state across iterations with `get_previous_state()` and `set_cycle_state()`
+- **Convergence Detection**: Automatic trend analysis with `detect_convergence_trend()`
+- **Value Accumulation**: Track metrics over time with `accumulate_values()`
+- **Safety Limits**: Max iterations prevent infinite loops
+- **Performance**: Optimized execution with ~30,000 iterations/second
+- **Developer Tools**: CycleAnalyzer, CycleDebugger, CycleProfiler for production workflows
+
+Common cyclic patterns include:
+- **Retry with Backoff**: ETL pipelines with automatic retry
+- **Optimization Loops**: Iterative parameter tuning
+- **ML Training**: Training until accuracy threshold
+- **Polling**: API polling with rate limiting
+- **Stream Processing**: Windowed data processing
+
 ### Workflow API Wrapper - Expose Workflows as REST APIs
 
 Transform any Kailash workflow into a production-ready REST API in just 3 lines of code:
@@ -1102,6 +1249,95 @@ This example demonstrates:
 - **Context formatting** for LLM input
 - **Answer generation** using Ollama's llama3.2 model
 
+### 🔒 Access Control and Security
+
+Kailash SDK provides comprehensive access control and security features for enterprise deployments:
+
+#### Role-Based Access Control (RBAC)
+```python
+from kailash.access_control import UserContext, PermissionRule, NodePermission
+from kailash.runtime.access_controlled import AccessControlledRuntime
+
+# Define user with roles
+user = UserContext(
+    user_id="analyst_001",
+    tenant_id="company_abc",
+    email="analyst@company.com",
+    roles=["analyst", "viewer"]
+)
+
+# Create secure runtime
+runtime = AccessControlledRuntime(user_context=user)
+
+# Execute workflow with automatic permission checks
+results, run_id = runtime.execute(workflow, parameters={})
+```
+
+#### Multi-Tenant Isolation
+```python
+from kailash.access_control import get_access_control_manager, PermissionEffect, WorkflowPermission
+
+# Configure tenant-based access rules
+acm = get_access_control_manager()
+acm.enabled = True
+
+# Tenant isolation rule
+acm.add_rule(PermissionRule(
+    id="tenant_isolation",
+    resource_type="workflow",
+    resource_id="customer_analytics",
+    permission=WorkflowPermission.EXECUTE,
+    effect=PermissionEffect.ALLOW,
+    tenant_id="company_abc"  # Only this tenant can access
+))
+```
+
+#### Data Masking and Field Protection
+```python
+from kailash.nodes.base_with_acl import add_access_control
+
+# Add access control to sensitive data nodes
+secure_reader = add_access_control(
+    CSVReaderNode(file_path="customers.csv"),
+    enable_access_control=True,
+    required_permission=NodePermission.READ_OUTPUT,
+    mask_output_fields=["ssn", "phone"]  # Mask for non-admin users
+)
+
+workflow.add_node("secure_data", secure_reader)
+```
+
+#### Permission-Based Routing
+```python
+# Different execution paths based on user permissions
+from kailash.access_control import NodePermission
+
+# Admin users get full processing
+admin_processor = PythonCodeNode.from_function(
+    lambda data: {"result": process_all_data(data)},
+    name="admin_processor"
+)
+
+# Analyst users get limited processing
+analyst_processor = PythonCodeNode.from_function(
+    lambda data: {"result": process_limited_data(data)},
+    name="analyst_processor"
+)
+
+# Runtime automatically routes based on user permissions
+workflow.add_node("admin_path", admin_processor)
+workflow.add_node("analyst_path", analyst_processor)
+```
+
+**Security Features:**
+- 🔐 **JWT Authentication**: Token-based authentication with refresh support
+- 👥 **Multi-Tenant Isolation**: Complete data separation between tenants
+- 🛡️ **Field-Level Security**: Mask sensitive data based on user roles
+- 📊 **Audit Logging**: Complete access attempt logging for compliance
+- 🚫 **Path Traversal Prevention**: Built-in protection against directory attacks
+- 🏗️ **Backward Compatibility**: Existing workflows work unchanged
+- ⚡ **Performance Optimized**: Minimal overhead with caching
+
 ## 💻 CLI Commands
 
 The SDK includes a comprehensive CLI for workflow management:
@@ -1298,6 +1534,10 @@ pre-commit run pytest-check
 - Immutable state management
 - API integration with rate limiting
 - OAuth 2.0 authentication
+- Production security framework
+- Path traversal prevention
+- Code execution sandboxing
+- Comprehensive security testing
 - SharePoint Graph API integration
 - **Self-organizing agent pools with 13 specialized nodes**
 - **Agent-to-agent communication and shared memory**
@@ -1308,16 +1548,19 @@ pre-commit run pytest-check
 - **Performance visualization dashboards**
 - **Real-time monitoring dashboard with WebSocket streaming**
 - **Comprehensive performance reports (HTML, Markdown, JSON)**
-- **89% test coverage (571 tests)**
-- **15 test categories all passing**
-- 37 working examples
+- **100% test coverage (591 tests)**
+- **All test categories passing**
+- 68 working examples
 
 </td>
 <td width="30%">
 
 ### 🚧 In Progress
-- Comprehensive API documentation
-- Security audit & hardening
+- **Kailash Workflow Studio** - Visual workflow builder UI
+  - React-based drag-and-drop interface
+  - Multi-tenant architecture with Docker
+  - WorkflowStudioAPI backend
+  - Real-time execution monitoring
 - Performance optimizations
 - Docker runtime finalization
 
@@ -1335,11 +1578,12 @@ pre-commit run pytest-check
 </table>
 
 ### 🎯 Test Suite Status
-- **Total Tests**: 571 passing (89%)
-- **Test Categories**: 15/15 at 100%
-- **Integration Tests**: 65 passing
-- **Examples**: 37/37 working
-- **Code Coverage**: 89%
+- **Total Tests**: 591 passing (100%)
+- **Test Categories**: All passing
+- **Integration Tests**: All passing
+- **Security Tests**: 10 consolidated comprehensive tests
+- **Examples**: 68/68 working
+- **Code Coverage**: 100%
 
 ## ⚠️ Known Issues
 

{kailash-0.1.5 → kailash-0.2.0}/README.md

@@ -6,7 +6,7 @@
   <a href="https://pepy.tech/project/kailash"><img src="https://static.pepy.tech/badge/kailash" alt="Downloads"></a>
   <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="MIT License">
   <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
-  <img src="https://img.shields.io/badge/tests-753%20passing-brightgreen.svg" alt="Tests: 753 passing">
+  <img src="https://img.shields.io/badge/tests-734%20passing-brightgreen.svg" alt="Tests: 734 passing">
   <img src="https://img.shields.io/badge/coverage-100%25-brightgreen.svg" alt="Coverage: 100%">
 </p>
 
@@ -34,6 +34,11 @@
 - 🚪 **Multi-Workflow Gateway**: Manage multiple workflows through unified API with MCP integration
 - 🤖 **Self-Organizing Agents**: Autonomous agent pools with intelligent team formation and convergence detection
 - 🧠 **Agent-to-Agent Communication**: Shared memory pools and intelligent caching for coordinated multi-agent systems
+- 🔒 **Production Security**: Comprehensive security framework with path traversal prevention, code sandboxing, and audit logging
+- 🎨 **Visual Workflow Builder**: Kailash Workflow Studio - drag-and-drop interface for creating and managing workflows (coming soon)
+- 🔁 **Cyclic Workflows (v0.2.0)**: Universal Hybrid Cyclic Graph Architecture with 30,000+ iterations/second performance
+- 🛠️ **Developer Tools**: CycleAnalyzer, CycleDebugger, CycleProfiler for production-ready cyclic workflows
+- 📈 **High Performance**: Optimized execution engine supporting 100,000+ iteration workflows
 
 ## 🎯 Who Is This For?
 
@@ -218,6 +223,141 @@ results, run_id = runtime.execute(workflow)
 print("RAG Response:", results["llm_agent"]["response"])
 ```
 
+### Cyclic Workflows - Iterative Processing with Convergence
+
+Build workflows that iterate until a condition is met, perfect for optimization, retries, and ML training:
+
+```python
+from kailash.workflow import Workflow
+from kailash.nodes.base_cycle_aware import CycleAwareNode
+from kailash.nodes.base import NodeParameter
+from kailash.runtime.local import LocalRuntime
+from typing import Any, Dict
+
+# Create a custom cycle-aware node for data quality improvement
+class DataQualityImproverNode(CycleAwareNode):
+    def get_parameters(self) -> Dict[str, NodeParameter]:
+        return {
+            "data": NodeParameter(name="data", type=list, required=True),
+            "target_quality": NodeParameter(name="target_quality", type=float, required=False, default=0.95)
+        }
+
+    def run(self, context: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        """Iteratively improve data quality."""
+        data = kwargs["data"]
+        target_quality = kwargs.get("target_quality", 0.95)
+
+        # Get current iteration and previous state
+        iteration = self.get_iteration(context)
+        prev_state = self.get_previous_state(context)
+
+        # Calculate current quality
+        quality = prev_state.get("quality", 0.5) + 0.1  # Improve by 10% each iteration
+        quality = min(quality, 1.0)
+
+        # Process data (simplified)
+        processed_data = [item for item in data if item is not None]
+
+        # Track quality history
+        quality_history = self.accumulate_values(context, "quality_history", quality, max_history=10)
+
+        # Detect convergence trend
+        trend = self.detect_convergence_trend(context, "quality_history", window_size=5)
+        converged = quality >= target_quality or (trend and trend["slope"] < 0.01)
+
+        # Log progress
+        self.log_cycle_info(context, f"Iteration {iteration}: Quality={quality:.2%}")
+
+        # Save state for next iteration
+        self.set_cycle_state({"quality": quality, "processed_count": len(processed_data)})
+
+        return {
+            "data": processed_data,
+            "quality": quality,
+            "converged": converged,
+            "iteration": iteration,
+            "history": quality_history
+        }
+
+# Build cyclic workflow
+workflow = Workflow("quality_improvement", "Iterative Data Quality")
+workflow.add_node("improver", DataQualityImproverNode())
+
+# Create a cycle - node connects to itself!
+workflow.connect("improver", "improver",
+                 mapping={"data": "data"},  # Pass data to next iteration
+                 cycle=True,  # This is a cycle
+                 max_iterations=20,  # Safety limit
+                 convergence_check="converged == True")  # Stop condition
+
+# Execute with automatic iteration management
+runtime = LocalRuntime()
+results, run_id = runtime.execute(workflow, parameters={
+    "improver": {
+        "data": [1, None, 3, None, 5, 6, None, 8, 9, 10],
+        "target_quality": 0.9
+    }
+})
+
+print(f"Converged after {results['improver']['iteration']} iterations")
+print(f"Final quality: {results['improver']['quality']:.2%}")
+print(f"Quality history: {results['improver']['history']}")
+```
+
+### NEW in v0.2.0: CycleBuilder API
+
+The new CycleBuilder API provides a fluent interface for creating cyclic workflows:
+
+```python
+# Modern approach with CycleBuilder
+workflow.create_cycle("optimization_loop")
+    .connect("gradient", "optimizer")
+    .connect("optimizer", "evaluator")
+    .connect("evaluator", "gradient")
+    .max_iterations(100)
+    .converge_when("loss < 0.01")
+    .early_stop_when("gradient_norm < 1e-6")
+    .checkpoint_every(10)
+    .build()
+
+# Developer tools for production workflows
+from kailash.workflow import CycleAnalyzer, CycleDebugger, CycleProfiler
+
+# Analyze cycle patterns
+analyzer = CycleAnalyzer(workflow)
+report = analyzer.analyze()
+print(f"Found {len(report.cycles)} cycles")
+print(f"Max depth: {report.max_cycle_depth}")
+
+# Debug with breakpoints
+debugger = CycleDebugger(workflow)
+debugger.set_breakpoint("optimizer", iteration=50)
+debugger.set_trace("gradient_norm", lambda x: x < 0.001)
+
+# Profile performance
+profiler = CycleProfiler(workflow)
+profile_data = profiler.profile(runtime, parameters)
+print(f"Bottleneck: {profile_data.bottleneck_node}")
+print(f"Iterations/sec: {profile_data.iterations_per_second}")
+```
+
+#### Cyclic Workflow Features
+
+- **Built-in Iteration Management**: No manual loops or recursion needed
+- **State Persistence**: Maintain state across iterations with `get_previous_state()` and `set_cycle_state()`
+- **Convergence Detection**: Automatic trend analysis with `detect_convergence_trend()`
+- **Value Accumulation**: Track metrics over time with `accumulate_values()`
+- **Safety Limits**: Max iterations prevent infinite loops
+- **Performance**: Optimized execution with ~30,000 iterations/second
+- **Developer Tools**: CycleAnalyzer, CycleDebugger, CycleProfiler for production workflows
+
+Common cyclic patterns include:
+- **Retry with Backoff**: ETL pipelines with automatic retry
+- **Optimization Loops**: Iterative parameter tuning
+- **ML Training**: Training until accuracy threshold
+- **Polling**: API polling with rate limiting
+- **Stream Processing**: Windowed data processing
+
 ### Workflow API Wrapper - Expose Workflows as REST APIs
 
 Transform any Kailash workflow into a production-ready REST API in just 3 lines of code:
@@ -1042,6 +1182,95 @@ This example demonstrates:
 - **Context formatting** for LLM input
 - **Answer generation** using Ollama's llama3.2 model
 
+### 🔒 Access Control and Security
+
+Kailash SDK provides comprehensive access control and security features for enterprise deployments:
+
+#### Role-Based Access Control (RBAC)
+```python
+from kailash.access_control import UserContext, PermissionRule, NodePermission
+from kailash.runtime.access_controlled import AccessControlledRuntime
+
+# Define user with roles
+user = UserContext(
+    user_id="analyst_001",
+    tenant_id="company_abc",
+    email="analyst@company.com",
+    roles=["analyst", "viewer"]
+)
+
+# Create secure runtime
+runtime = AccessControlledRuntime(user_context=user)
+
+# Execute workflow with automatic permission checks
+results, run_id = runtime.execute(workflow, parameters={})
+```
+
+#### Multi-Tenant Isolation
+```python
+from kailash.access_control import get_access_control_manager, PermissionEffect, WorkflowPermission
+
+# Configure tenant-based access rules
+acm = get_access_control_manager()
+acm.enabled = True
+
+# Tenant isolation rule
+acm.add_rule(PermissionRule(
+    id="tenant_isolation",
+    resource_type="workflow",
+    resource_id="customer_analytics",
+    permission=WorkflowPermission.EXECUTE,
+    effect=PermissionEffect.ALLOW,
+    tenant_id="company_abc"  # Only this tenant can access
+))
+```
+
+#### Data Masking and Field Protection
+```python
+from kailash.nodes.base_with_acl import add_access_control
+
+# Add access control to sensitive data nodes
+secure_reader = add_access_control(
+    CSVReaderNode(file_path="customers.csv"),
+    enable_access_control=True,
+    required_permission=NodePermission.READ_OUTPUT,
+    mask_output_fields=["ssn", "phone"]  # Mask for non-admin users
+)
+
+workflow.add_node("secure_data", secure_reader)
+```
+
+#### Permission-Based Routing
+```python
+# Different execution paths based on user permissions
+from kailash.access_control import NodePermission
+
+# Admin users get full processing
+admin_processor = PythonCodeNode.from_function(
+    lambda data: {"result": process_all_data(data)},
+    name="admin_processor"
+)
+
+# Analyst users get limited processing
+analyst_processor = PythonCodeNode.from_function(
+    lambda data: {"result": process_limited_data(data)},
+    name="analyst_processor"
+)
+
+# Runtime automatically routes based on user permissions
+workflow.add_node("admin_path", admin_processor)
+workflow.add_node("analyst_path", analyst_processor)
+```
+
+**Security Features:**
+- 🔐 **JWT Authentication**: Token-based authentication with refresh support
+- 👥 **Multi-Tenant Isolation**: Complete data separation between tenants
+- 🛡️ **Field-Level Security**: Mask sensitive data based on user roles
+- 📊 **Audit Logging**: Complete access attempt logging for compliance
+- 🚫 **Path Traversal Prevention**: Built-in protection against directory attacks
+- 🏗️ **Backward Compatibility**: Existing workflows work unchanged
+- ⚡ **Performance Optimized**: Minimal overhead with caching
+
 ## 💻 CLI Commands
 
 The SDK includes a comprehensive CLI for workflow management:
@@ -1238,6 +1467,10 @@ pre-commit run pytest-check
 - Immutable state management
 - API integration with rate limiting
 - OAuth 2.0 authentication
+- Production security framework
+- Path traversal prevention
+- Code execution sandboxing
+- Comprehensive security testing
 - SharePoint Graph API integration
 - **Self-organizing agent pools with 13 specialized nodes**
 - **Agent-to-agent communication and shared memory**
@@ -1248,16 +1481,19 @@ pre-commit run pytest-check
 - **Performance visualization dashboards**
 - **Real-time monitoring dashboard with WebSocket streaming**
 - **Comprehensive performance reports (HTML, Markdown, JSON)**
-- **89% test coverage (571 tests)**
-- **15 test categories all passing**
-- 37 working examples
+- **100% test coverage (591 tests)**
+- **All test categories passing**
+- 68 working examples
 
 </td>
 <td width="30%">
 
 ### 🚧 In Progress
-- Comprehensive API documentation
-- Security audit & hardening
+- **Kailash Workflow Studio** - Visual workflow builder UI
+  - React-based drag-and-drop interface
+  - Multi-tenant architecture with Docker
+  - WorkflowStudioAPI backend
+  - Real-time execution monitoring
 - Performance optimizations
 - Docker runtime finalization
 
@@ -1275,11 +1511,12 @@ pre-commit run pytest-check
 </table>
 
 ### 🎯 Test Suite Status
-- **Total Tests**: 571 passing (89%)
-- **Test Categories**: 15/15 at 100%
-- **Integration Tests**: 65 passing
-- **Examples**: 37/37 working
-- **Code Coverage**: 89%
+- **Total Tests**: 591 passing (100%)
+- **Test Categories**: All passing
+- **Integration Tests**: All passing
+- **Security Tests**: 10 consolidated comprehensive tests
+- **Examples**: 68/68 working
+- **Code Coverage**: 100%
 
 ## ⚠️ Known Issues
 

{kailash-0.1.5 → kailash-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kailash"
-version = "0.1.5"
+version = "0.2.0"
 description = "Python SDK for the Kailash container-node architecture"
 authors = [
     {name = "Integrum", email = "info@integrum.com"}
@@ -51,6 +51,13 @@ dependencies = [
     "pre-commit>=4.2.0",
     "twine>=6.1.0",
     "ollama>=0.5.1",
+    "sqlalchemy>=2.0.0",
+    "websockets>=12.0",
+    "httpx>=0.25.0",
+    "python-jose>=3.5.0",
+    "pytest-xdist>=3.6.0",
+    "pytest-timeout>=2.3.0",
+    "pytest-split>=0.9.0",
 ]
 
 [project.optional-dependencies]

{kailash-0.1.5 → kailash-0.2.0}/setup.py

@@ -13,7 +13,7 @@ with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
 # Package configuration
 setup(
     name="kailash",
-    version="0.1.4",
+    version="0.2.0",
     author="Integrum",
     author_email="info@integrum.com",
     description="Python SDK for the Kailash container-node architecture",

{kailash-0.1.5 → kailash-0.2.0}/src/kailash/__init__.py

@@ -15,7 +15,7 @@ from kailash.workflow.visualization import WorkflowVisualizer
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.1.4"
+__version__ = "0.2.0"
 
 __all__ = [
     "Workflow",