cvkg-cli 0.1.22

//! Dev Runtime Controller
//! Responsible for launching runtime, maintaining connection, and coordinating updates

use serde::{Deserialize, Serialize};
use std::sync::Arc;

use crate::patch_engine::{CompiledArtifact, PatchEngine, RuntimePatch};

/// Abstract runtime handle trait
pub trait RuntimeHandle: Send + Sync {
    /// Send a patch to the runtime
    fn send_patch(&self, patch: RuntimePatch);

    /// Request current state from the runtime
    fn request_state(&self) -> RuntimeStateSnapshot;

    /// Send an event to the runtime
    fn send_event(&self, event: RuntimeEvent);
}

/// DevRuntimeController manages the connection to the runtime
pub struct DevRuntimeController {
    runtime: Arc<dyn RuntimeHandle>,
    patch_engine: PatchEngine,
}

impl DevRuntimeController {
    /// Create a new DevRuntimeController
    pub fn new(runtime: Arc<dyn RuntimeHandle>) -> Self {
        Self {
            runtime,
            patch_engine: PatchEngine::new(),
        }
    }

    /// Apply a code update by generating and sending a patch
    pub fn apply_code_update(&mut self, compiled_artifact: CompiledArtifact) {
        let patch = self.patch_engine.generate_patch(compiled_artifact);
        self.runtime.send_patch(patch);
    }

    /// Inject an agent stream into the runtime
    pub fn inject_agent_stream(&self, stream: Vec<RuntimeEvent>) {
        for event in stream {
            self.runtime.send_event(event);
        }
    }
}

/// Runtime event types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RuntimeEvent {
    Agent(AgentEvent),
    // Add other event types as needed
}

/// Agent event types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AgentEvent {
    Token(String),
    ToolCall(String),
    StateChange(String),
    Error(String),
}

/// Runtime state snapshot
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RuntimeStateSnapshot {
    // In a full implementation, this would contain the serialized state graph
    pub data: String,
}

impl RuntimeStateSnapshot {
    pub fn new(data: String) -> Self {
        Self { data }
    }
}