Struct MultiLayerExtractor 

pub struct MultiLayerExtractor { /* private fields */ }

Multi-layer extractor for maximum reliability

This combines all four detection layers:

1. Native Hooks (100%): Direct agent integration
2. Session Monitor (95%): Process monitoring
3. Inactivity Detector (90%): Timeout detection
4. Persistent Buffer (99%): Crash recovery

Example

use nexus_hooks::{HookFactory, MultiLayerExtractor};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let factory = HookFactory::new();
    let hook = factory.create_hook("claude-code")?;

    let extractor = MultiLayerExtractor::new()
        .with_hook(hook)
        .await?;

    // Start monitoring
    extractor.start().await?;

    // Extract context
    let context = extractor.extract().await?;
    println!("Extracted: {:?}", context);

    // Stop and flush
    extractor.stop().await?;

    Ok(())
}

Implementations

impl MultiLayerExtractor

pub fn new() -> Result<Self>

Create a new multi-layer extractor

pub async fn with_hook(self, hook: Box<dyn AgentHook>) -> Result<Self>

Add a hook to the extractor

pub fn subscribe(&self) -> Receiver<ExtractionEvent>

Subscribe to extraction events

pub async fn start(&self) -> Result<()>

Start all detection layers

pub async fn stop(&self) -> Result<()>

Stop all detection layers

pub async fn extract(&self, agent_type: &str) -> Result<SessionContext>

Extract context for an agent

pub async fn stats(&self) -> ExtractionStats

Get extraction statistics

pub async fn is_active(&self) -> bool

Check if extraction is active

pub async fn trigger_extraction(&self, agent_type: &str) -> Result<HookResult>

Manually trigger extraction for an agent

pub async fn check_for_recovery(&self) -> Result<Vec<(String, BufferData)>>

Check for buffered data to recover

pub async fn clear_buffer(&self, agent_type: &str) -> Result<()>

Clear buffer for an agent

Trait Implementations

impl Default for MultiLayerExtractor

fn default() -> Self

Returns the “default value” for a type.