DAA Rules

🚀 FULL IMPLEMENTATION - This is the complete, production-ready implementation of the DAA Rules Engine, not a placeholder.

A comprehensive rules engine for the Decentralized Autonomous Agents (DAA) system, providing policy enforcement, decision automation, and governance capabilities.

Overview

DAA Rules provides a flexible and powerful rules engine that enables autonomous agents to make decisions based on predefined policies and conditions. The engine supports complex logical operations, pattern matching, time-based conditions, and various action types.

Features

Core Rule Engine

Rule Definition: Flexible rule creation with conditions and actions
Condition Evaluation: Support for equality, comparison, pattern matching, and logical operations
Action Execution: Set fields, log messages, send notifications, and custom actions
Context Management: Execution context with variables and metadata

Advanced Features

Complex Logic: AND, OR, NOT operations for sophisticated rule conditions
Pattern Matching: Regular expression support for text matching
Time-based Rules: Temporal conditions and scheduling
Priority System: Rule execution order based on priority levels
Validation: Comprehensive rule and condition validation

Optional Features

Scripting Support: Execute custom scripts within rules (with scripting feature)
Database Storage: Persistent rule storage (with database feature)
Custom Extensions: Pluggable condition and action types

Architecture

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   RuleEngine    │    │ConditionEvaluator│    │ ActionExecutor  │
│                 │    │                 │    │                 │
│ - Rule Storage  │◄──►│ - Equals/Compare│◄──►│ - SetField      │
│ - Execution     │    │ - Pattern Match │    │ - Log Message   │
│ - Validation    │    │ - Logic Ops     │    │ - Notifications │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│ExecutionContext │    │   RuleStorage   │    │   Scripting     │
│                 │    │                 │    │   (Optional)    │
│ - Variables     │    │ - InMemory      │    │ - Rhai Engine   │
│ - Metadata      │    │ - Database      │    │ - Custom Scripts│
│ - Timestamp     │    │ - File System   │    │ - Extensions    │
└─────────────────┘    └─────────────────┘    └─────────────────┘

Usage

Basic Rule Creation

use daa_rules::{Rule, RuleCondition, RuleAction, LogLevel};

// Create a simple rule
let rule = Rule::new_with_generated_id(
    "Agent Status Check".to_string(),
    vec![
        RuleCondition::Equals {
            field: "agent_status".to_string(),
            value: "active".to_string(),
        },
        RuleCondition::GreaterThan {
            field: "performance_score".to_string(),
            value: 0.8,
        },
    ],
    vec![
        RuleAction::Log {
            level: LogLevel::Info,
            message: "High-performing active agent detected".to_string(),
        },
        RuleAction::SetField {
            field: "eligibility".to_string(),
            value: "premium".to_string(),
        },
    ],
);

println!("Created rule: {}", rule.name);

Rules Engine Setup

use daa_rules::{RuleEngine, ExecutionContext};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create rules engine
    let mut engine = RuleEngine::new();
    
    // Add rule to engine
    engine.add_rule(rule).await?;
    
    // Create execution context
    let mut context = ExecutionContext::new();
    context.set_variable("agent_status".to_string(), "active".to_string());
    context.set_variable("performance_score".to_string(), "0.85".to_string());
    
    // Execute rule
    let result = engine.execute_rule(&rule, &mut context).await?;
    println!("Rule execution result: {}", result);
    
    Ok(())
}

Complex Conditions

use daa_rules::{RuleCondition, TimeOperator};
use chrono::{Utc, Duration};

// Complex logical condition
let complex_condition = RuleCondition::And {
    conditions: vec![
        RuleCondition::Or {
            conditions: vec![
                RuleCondition::Equals {
                    field: "task_type".to_string(),
                    value: "compute".to_string(),
                },
                RuleCondition::Equals {
                    field: "task_type".to_string(),
                    value: "storage".to_string(),
                },
            ],
        },
        RuleCondition::Not {
            condition: Box::new(RuleCondition::Equals {
                field: "agent_status".to_string(),
                value: "suspended".to_string(),
            }),
        },
        RuleCondition::TimeCondition {
            field: "last_active".to_string(),
            operator: TimeOperator::After,
            value: Utc::now() - Duration::hours(24),
        },
    ],
};

Pattern Matching

// Email validation rule
let email_rule = Rule::new_with_generated_id(
    "Email Validation".to_string(),
    vec![
        RuleCondition::Matches {
            field: "email".to_string(),
            pattern: r"^[^@]+@[^@]+\.[^@]+$".to_string(),
        },
    ],
    vec![
        RuleAction::SetField {
            field: "email_valid".to_string(),
            value: "true".to_string(),
        },
    ],
);

// IP address validation
let ip_rule = Rule::new_with_generated_id(
    "IP Address Check".to_string(),
    vec![
        RuleCondition::Matches {
            field: "client_ip".to_string(),
            pattern: r"^192\.168\.1\.\d{1,3}$".to_string(),
        },
    ],
    vec![
        RuleAction::SetField {
            field: "network_zone".to_string(),
            value: "internal".to_string(),
        },
    ],
);

Action Types

use daa_rules::{RuleAction, LogLevel, NotificationChannel};
use std::collections::HashMap;

// Logging action
let log_action = RuleAction::Log {
    level: LogLevel::Warn,
    message: "Unusual activity detected".to_string(),
};

// Field modification
let set_field_action = RuleAction::SetField {
    field: "alert_level".to_string(),
    value: "high".to_string(),
};

// Notification
let notify_action = RuleAction::Notify {
    recipient: "admin@example.com".to_string(),
    message: "Security alert triggered".to_string(),
    channel: NotificationChannel::Email,
};

// Context modification
let mut modifications = HashMap::new();
modifications.insert("processed".to_string(), "true".to_string());
modifications.insert("processor".to_string(), "security_agent".to_string());

let modify_context_action = RuleAction::ModifyContext {
    modifications,
};

// Webhook trigger
let mut headers = HashMap::new();
headers.insert("Authorization".to_string(), "Bearer token".to_string());
headers.insert("Content-Type".to_string(), "application/json".to_string());

let webhook_action = RuleAction::Webhook {
    url: "https://api.example.com/alerts".to_string(),
    method: "POST".to_string(),
    headers,
    body: r#"{"alert": "security_event", "level": "high"}"#.to_string(),
};

Rule Definition Examples

Agent Performance Monitoring

let performance_rule = Rule::new_with_generated_id(
    "Performance Monitoring".to_string(),
    vec![
        RuleCondition::LessThan {
            field: "success_rate".to_string(),
            value: 0.7, // Below 70% success rate
        },
        RuleCondition::GreaterThan {
            field: "task_count".to_string(),
            value: 10.0, // More than 10 tasks
        },
    ],
    vec![
        RuleAction::Log {
            level: LogLevel::Warn,
            message: "Agent performance below threshold".to_string(),
        },
        RuleAction::SetField {
            field: "performance_status".to_string(),
            value: "review_required".to_string(),
        },
        RuleAction::Notify {
            recipient: "performance_monitor".to_string(),
            message: "Agent requires performance review".to_string(),
            channel: NotificationChannel::Internal,
        },
    ],
);

Resource Allocation

let resource_rule = Rule::new_with_generated_id(
    "Resource Allocation".to_string(),
    vec![
        RuleCondition::In {
            field: "agent_tier".to_string(),
            values: vec!["premium".to_string(), "enterprise".to_string()],
        },
        RuleCondition::LessThan {
            field: "current_load".to_string(),
            value: 0.8, // Below 80% load
        },
    ],
    vec![
        RuleAction::SetField {
            field: "resource_allocation".to_string(),
            value: "high".to_string(),
        },
        RuleAction::SetField {
            field: "priority_queue".to_string(),
            value: "fast_track".to_string(),
        },
    ],
);

Security Policy

let security_rule = Rule::new_with_generated_id(
    "Security Policy".to_string(),
    vec![
        RuleCondition::And {
            conditions: vec![
                RuleCondition::Matches {
                    field: "request_path".to_string(),
                    pattern: r"/admin/.*".to_string(),
                },
                RuleCondition::NotEquals {
                    field: "user_role".to_string(),
                    value: "administrator".to_string(),
                },
            ],
        },
    ],
    vec![
        RuleAction::Log {
            level: LogLevel::Error,
            message: "Unauthorized admin access attempt".to_string(),
        },
        RuleAction::Abort {
            reason: "Insufficient privileges for admin access".to_string(),
        },
    ],
);

Configuration

Basic Configuration

use daa_rules::RuleEngine;

// Create engine with default settings
let engine = RuleEngine::new();

With Database Storage

[dependencies]
daa-rules = { version = "0.2.0", features = ["database"] }

#[cfg(feature = "database")]
use daa_rules::database::DatabaseStorage;

// Create engine with database storage
let storage = DatabaseStorage::new("sqlite://rules.db").await?;
let mut engine = RuleEngine::with_storage(Box::new(storage));

With Scripting Support

[dependencies]
daa-rules = { version = "0.2.0", features = ["scripting"] }

#[cfg(feature = "scripting")]
use daa_rules::RuleAction;

let script_action = RuleAction::Script {
    script_type: "rhai".to_string(),
    script: r#"
        let result = performance_score * quality_multiplier;
        if result > 0.9 {
            set_field("bonus_eligible", "true");
        }
    "#.to_string(),
};

Features

The crate supports several feature flags:

default: Basic rules engine functionality
basic: Core features only (same as default)
scripting: Enables Rhai scripting support for custom actions
database: Adds SQLite database storage for rules
full: Includes all features

[dependencies]
daa-rules = { version = "0.2.0", features = ["full"] }

Integration with DAA System

With DAA Chain

// Rules can be integrated with blockchain operations
let chain_rule = Rule::new_with_generated_id(
    "Blockchain Validation".to_string(),
    vec![
        RuleCondition::GreaterThan {
            field: "transaction_amount".to_string(),
            value: 1000.0,
        },
    ],
    vec![
        RuleAction::Custom {
            action_type: "blockchain_verify".to_string(),
            parameters: {
                let mut params = HashMap::new();
                params.insert("verification_level".to_string(), "enhanced".to_string());
                params
            },
        },
    ],
);

With DAA Economy

// Economic policy enforcement
let economic_rule = Rule::new_with_generated_id(
    "Economic Policy".to_string(),
    vec![
        RuleCondition::And {
            conditions: vec![
                RuleCondition::Equals {
                    field: "transaction_type".to_string(),
                    value: "reward".to_string(),
                },
                RuleCondition::GreaterThan {
                    field: "performance_score".to_string(),
                    value: 0.95,
                },
            ],
        },
    ],
    vec![
        RuleAction::Custom {
            action_type: "apply_bonus".to_string(),
            parameters: {
                let mut params = HashMap::new();
                params.insert("bonus_multiplier".to_string(), "1.5".to_string());
                params
            },
        },
    ],
);

API Reference

RuleEngine

Main rules engine for executing policies.

Key Methods:

new() - Create new rules engine
add_rule(rule) - Add rule to engine
execute_rule(rule, context) - Execute specific rule
evaluate_condition(condition, context) - Evaluate condition
execute_action(action, context) - Execute action

Rule

Individual rule definition with conditions and actions.

Key Methods:

new(id, name, conditions, actions) - Create new rule
new_with_generated_id(name, conditions, actions) - Create with auto-generated ID
is_valid() - Validate rule definition

ExecutionContext

Context for rule execution containing variables and metadata.

Key Methods:

new() - Create new context
set_variable(key, value) - Set context variable
get_variable(key) - Get context variable
set_metadata(key, value) - Set metadata

Testing

Run the test suite:

# Basic tests
cargo test --package daa-rules

# All features
cargo test --package daa-rules --all-features

# Specific feature
cargo test --package daa-rules --features scripting

Examples

See the /examples directory for comprehensive usage examples:

basic_rules.rs - Simple rule creation and execution
complex_conditions.rs - Advanced logical conditions
pattern_matching.rs - Regular expression usage
time_based_rules.rs - Temporal conditions
custom_actions.rs - Extending with custom actions

Performance

The rules engine is designed for high performance:

Fast Evaluation: Optimized condition evaluation with short-circuiting
Memory Efficient: Minimal memory overhead for rule storage
Concurrent Safe: Thread-safe execution with async support
Scalable: Handles thousands of rules efficiently

License

MIT OR Apache-2.0

daa-rules 0.2.1

DAA Rules

Overview

Features

Core Rule Engine

Advanced Features

Optional Features

Architecture

Usage

Basic Rule Creation

Rules Engine Setup

Complex Conditions

Pattern Matching

Action Types

Rule Definition Examples

Agent Performance Monitoring

Resource Allocation

Security Policy

Configuration

Basic Configuration

With Database Storage

With Scripting Support

Features

Integration with DAA System

With DAA Chain

With DAA Economy

API Reference

RuleEngine

Rule

ExecutionContext

Testing

Examples

Performance

License