pi-oxidized 0.1.1

package/.agent-tasks/pi-rust-rewrite/tests/rpc_parity.rs

@@ -0,0 +1,679 @@
+//! Check 10: RPC parity — replay every RpcCommand against the Rust RPC loop
+//! with a deterministic fake host, compare frames to the TypeScript harness
+//! goldens (and optionally re-run the TS harness), normalizing only ids,
+//! timestamps, and filesystem temp paths.
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use futures::future::BoxFuture;
+use pi::core::agent_session::extension::ExtensionBindings;
+use pi::core::agent_session::prompt::PreflightCallback;
+use pi::core::agent_session::AgentSessionEvent;
+use pi::core::agent_session_runtime::{ForkOutcome, ForkPosition};
+use pi::core::compaction::CompactionResult;
+use pi::core::sessions::SessionEntry;
+use pi::modes::rpc::{
+    run_rpc_loop, BashResult, BufferSink, ForkMessage, ModelCycleResult, RebindCallback,
+    RpcSessionHost, RpcSessionState, RpcSessionTreeNode, RpcSink, RpcSlashCommand, SessionStats,
+    StreamingBehavior,
+};
+use pi_agent::{AgentMessage, QueueMode};
+use pi_ai::{ImageContent, Model, ModelThinkingLevel};
+use serde_json::{json, Value};
+use tokio::io::AsyncWriteExt;
+
+type BoxUnsub = Box<dyn Fn() + Send + Sync>;
+
+fn fixtures_dir() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("fixtures/rpc")
+}
+
+fn load_json(name: &str) -> Value {
+    let path = fixtures_dir().join(name);
+    let text = std::fs::read_to_string(&path)
+        .unwrap_or_else(|e| panic!("read {}: {e}", path.display()));
+    serde_json::from_str(&text).unwrap_or_else(|e| panic!("parse {}: {e}", path.display()))
+}
+
+/// Normalize only generated ids, timestamps, and filesystem temp paths.
+fn canonicalize_number(n: &serde_json::Number) -> Value {
+    if let Some(i) = n.as_i64() {
+        return Value::Number(i.into());
+    }
+    if let Some(u) = n.as_u64() {
+        return Value::Number(u.into());
+    }
+    if let Some(f) = n.as_f64() {
+        if f.is_finite() && f.fract() == 0.0 && f >= i64::MIN as f64 && f <= i64::MAX as f64 {
+            return Value::Number((f as i64).into());
+        }
+        if let Some(nn) = serde_json::Number::from_f64(f) {
+            return Value::Number(nn);
+        }
+    }
+    Value::Number(n.clone())
+}
+
+fn normalize_value(value: &Value) -> Value {
+    match value {
+        Value::Object(map) => {
+            let mut out = serde_json::Map::new();
+            for (k, v) in map {
+                if is_id_key(k) {
+                    out.insert(k.clone(), json!("<id>"));
+                } else if is_timestamp_key(k) {
+                    out.insert(k.clone(), json!("<timestamp>"));
+                } else if is_path_key(k) {
+                    out.insert(k.clone(), normalize_path_str(v));
+                } else {
+                    out.insert(k.clone(), normalize_value(v));
+                }
+            }
+            Value::Object(out)
+        }
+        Value::Array(items) => Value::Array(items.iter().map(normalize_value).collect()),
+        Value::String(s) if looks_like_temp_path(s) => Value::String(normalize_path_text(s)),
+        // JSON number identity: 0 and 0.0 must compare equal across TS/Rust.
+        Value::Number(n) => canonicalize_number(n),
+        other => other.clone(),
+    }
+}
+
+fn is_id_key(key: &str) -> bool {
+    matches!(
+        key,
+        "id" | "entryId" | "leafId" | "sessionId" | "firstKeptEntryId" | "toolCallId" | "requestId"
+    )
+}
+
+fn is_timestamp_key(key: &str) -> bool {
+    matches!(key, "timestamp" | "createdAt" | "updatedAt" | "checkedAt")
+}
+
+fn is_path_key(key: &str) -> bool {
+    matches!(
+        key,
+        "path"
+            | "sessionFile"
+            | "sessionPath"
+            | "outputPath"
+            | "fullOutputPath"
+            | "parentSession"
+            | "baseDir"
+    ) || key.ends_with("Path")
+        || key.ends_with("File")
+}
+
+fn looks_like_temp_path(s: &str) -> bool {
+    s.contains("/tmp/")
+        || s.contains("\\Temp\\")
+        || s.contains("/var/folders/")
+        || s.contains("pi-rpc-parity")
+}
+
+fn normalize_path_str(value: &Value) -> Value {
+    match value {
+        Value::Null => Value::Null,
+        Value::String(s) => Value::String(normalize_path_text(s)),
+        other => normalize_value(other),
+    }
+}
+
+fn normalize_path_text(s: &str) -> String {
+    if looks_like_temp_path(s) {
+        let name = s.rsplit(['/', '\\']).next().unwrap_or("path");
+        format!("<tmp>/{name}")
+    } else {
+        s.to_owned()
+    }
+}
+
+fn normalize_frames(frames: &[Value]) -> Vec<Value> {
+    frames.iter().map(normalize_value).collect()
+}
+
+#[derive(Clone)]
+struct FakeHostConfig {
+    model: Model,
+    state: RpcSessionState,
+    cycle_model: Option<ModelCycleResult>,
+    cycle_thinking: Option<ModelThinkingLevel>,
+    compact: CompactionResult,
+    bash: BashResult,
+    stats: SessionStats,
+    export_html_path: String,
+    leaf_id: Option<String>,
+    fork_text: String,
+    session_op_cancelled: bool,
+    fork_messages: Vec<ForkMessage>,
+    last_assistant_text: Option<String>,
+    commands: Vec<RpcSlashCommand>,
+}
+
+impl FakeHostConfig {
+    fn from_fixture(host: &Value) -> Self {
+        let model: Model = serde_json::from_value(host["model"].clone())
+            .unwrap_or_else(|e| panic!("host model: {e}"));
+        let state: RpcSessionState = serde_json::from_value(host["state"].clone())
+            .unwrap_or_else(|e| panic!("host state: {e}"));
+        let cycle_raw = &host["cycleModel"];
+        let cycle_model = if cycle_raw.is_null() {
+            None
+        } else {
+            Some(ModelCycleResult {
+                model: serde_json::from_value(cycle_raw["model"].clone())
+                    .unwrap_or_else(|e| panic!("cycle model: {e}")),
+                thinking_level: serde_json::from_value(cycle_raw["thinkingLevel"].clone())
+                    .unwrap_or_else(|e| panic!("cycle thinking: {e}")),
+                is_scoped: cycle_raw["isScoped"].as_bool().unwrap_or(false),
+            })
+        };
+        let cycle_thinking: Option<ModelThinkingLevel> =
+            serde_json::from_value(host["cycleThinkingLevel"].clone())
+                .unwrap_or_else(|e| panic!("cycleThinkingLevel: {e}"));
+        let compact: CompactionResult = serde_json::from_value(host["compact"].clone())
+            .unwrap_or_else(|e| panic!("compact: {e}"));
+        let bash: BashResult = serde_json::from_value(host["bash"].clone())
+            .unwrap_or_else(|e| panic!("bash: {e}"));
+        let stats: SessionStats = serde_json::from_value(host["sessionStats"].clone())
+            .unwrap_or_else(|e| panic!("sessionStats: {e}"));
+        let fork_messages: Vec<ForkMessage> =
+            serde_json::from_value(host["forkMessages"].clone())
+                .unwrap_or_else(|e| panic!("forkMessages: {e}"));
+        let commands: Vec<RpcSlashCommand> = serde_json::from_value(host["commands"].clone())
+            .unwrap_or_else(|e| panic!("commands: {e}"));
+        Self {
+            model,
+            state,
+            cycle_model,
+            cycle_thinking,
+            compact,
+            bash,
+            stats,
+            export_html_path: host["exportHtmlPath"]
+                .as_str()
+                .unwrap_or("/tmp/pi-rpc-parity/session.html")
+                .to_owned(),
+            leaf_id: host["leafId"].as_str().map(str::to_owned),
+            fork_text: host["forkText"].as_str().unwrap_or("").to_owned(),
+            session_op_cancelled: host["sessionOpCancelled"].as_bool().unwrap_or(false),
+            fork_messages,
+            last_assistant_text: host["lastAssistantText"].as_str().map(str::to_owned),
+            commands,
+        }
+    }
+}
+
+struct FakeRpcHost {
+    cfg: Arc<Mutex<FakeHostConfig>>,
+    events_tx: Arc<Mutex<Option<tokio::sync::mpsc::UnboundedSender<AgentSessionEvent>>>>,
+    disposed: Arc<AtomicBool>,
+}
+
+impl FakeRpcHost {
+    fn new(cfg: FakeHostConfig) -> Self {
+        Self {
+            cfg: Arc::new(Mutex::new(cfg)),
+            events_tx: Arc::new(Mutex::new(None)),
+            disposed: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    fn lock_cfg(&self) -> std::sync::MutexGuard<'_, FakeHostConfig> {
+        self.cfg
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+    }
+}
+
+impl RpcSessionHost for FakeRpcHost {
+    fn prompt(
+        &self,
+        _message: String,
+        _images: Vec<ImageContent>,
+        _streaming_behavior: Option<StreamingBehavior>,
+        preflight: PreflightCallback,
+    ) -> BoxFuture<'static, Result<(), String>> {
+        // Synchronous preflight keeps response-before-events ordering stable
+        // under the test event loop (same FIFO contract as production).
+        preflight(true);
+        if let Some(tx) = self
+            .events_tx
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .as_ref()
+        {
+            let _ = tx.send(AgentSessionEvent::TurnStart);
+        }
+        Box::pin(async { Ok(()) })
+    }
+
+    fn steer(
+        &self,
+        _message: String,
+        _images: Vec<ImageContent>,
+    ) -> BoxFuture<'static, Result<(), String>> {
+        Box::pin(async { Ok(()) })
+    }
+
+    fn follow_up(
+        &self,
+        _message: String,
+        _images: Vec<ImageContent>,
+    ) -> BoxFuture<'static, Result<(), String>> {
+        Box::pin(async { Ok(()) })
+    }
+
+    fn abort(&self) -> BoxFuture<'static, ()> {
+        Box::pin(async {})
+    }
+
+    fn get_state(&self) -> BoxFuture<'static, RpcSessionState> {
+        let state = self.lock_cfg().state.clone();
+        Box::pin(async move { state })
+    }
+
+    fn get_available_models(&self) -> BoxFuture<'static, Vec<Model>> {
+        let model = self.lock_cfg().model.clone();
+        Box::pin(async move { vec![model] })
+    }
+
+    fn set_model(&self, model: Model) -> BoxFuture<'static, Result<(), String>> {
+        let cfg = Arc::clone(&self.cfg);
+        Box::pin(async move {
+            let mut guard = cfg
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            guard.model = model.clone();
+            guard.state.model = Some(model);
+            Ok(())
+        })
+    }
+
+    fn cycle_model(&self) -> BoxFuture<'static, Option<ModelCycleResult>> {
+        let value = self.lock_cfg().cycle_model.clone();
+        Box::pin(async move { value })
+    }
+
+    fn set_thinking_level(&self, level: ModelThinkingLevel) -> BoxFuture<'static, ()> {
+        let cfg = Arc::clone(&self.cfg);
+        Box::pin(async move {
+            cfg.lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .state
+                .thinking_level = level;
+        })
+    }
+
+    fn cycle_thinking_level(&self) -> BoxFuture<'static, Option<ModelThinkingLevel>> {
+        let value = self.lock_cfg().cycle_thinking;
+        Box::pin(async move { value })
+    }
+
+    fn set_steering_mode(&self, mode: QueueMode) -> BoxFuture<'static, ()> {
+        let cfg = Arc::clone(&self.cfg);
+        Box::pin(async move {
+            cfg.lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .state
+                .steering_mode = mode;
+        })
+    }
+
+    fn set_follow_up_mode(&self, mode: QueueMode) -> BoxFuture<'static, ()> {
+        let cfg = Arc::clone(&self.cfg);
+        Box::pin(async move {
+            cfg.lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .state
+                .follow_up_mode = mode;
+        })
+    }
+
+    fn compact(
+        &self,
+        _custom_instructions: Option<String>,
+    ) -> BoxFuture<'static, Result<CompactionResult, String>> {
+        let value = self.lock_cfg().compact.clone();
+        Box::pin(async move { Ok(value) })
+    }
+
+    fn set_auto_compaction(&self, enabled: bool) -> BoxFuture<'static, ()> {
+        let cfg = Arc::clone(&self.cfg);
+        Box::pin(async move {
+            cfg.lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .state
+                .auto_compaction_enabled = enabled;
+        })
+    }
+
+    fn set_auto_retry(&self, _enabled: bool) -> BoxFuture<'static, ()> {
+        Box::pin(async {})
+    }
+
+    fn abort_retry(&self) -> BoxFuture<'static, ()> {
+        Box::pin(async {})
+    }
+
+    fn execute_bash(
+        &self,
+        _command: String,
+        _exclude_from_context: Option<bool>,
+    ) -> BoxFuture<'static, Result<BashResult, String>> {
+        let value = self.lock_cfg().bash.clone();
+        Box::pin(async move { Ok(value) })
+    }
+
+    fn abort_bash(&self) -> BoxFuture<'static, ()> {
+        Box::pin(async {})
+    }
+
+    fn get_session_stats(&self) -> BoxFuture<'static, SessionStats> {
+        let value = self.lock_cfg().stats.clone();
+        Box::pin(async move { value })
+    }
+
+    fn export_to_html(
+        &self,
+        _output_path: Option<String>,
+    ) -> BoxFuture<'static, Result<String, String>> {
+        let path = self.lock_cfg().export_html_path.clone();
+        Box::pin(async move { Ok(path) })
+    }
+
+    fn set_session_name(&self, name: String) -> BoxFuture<'static, Result<(), String>> {
+        let cfg = Arc::clone(&self.cfg);
+        Box::pin(async move {
+            cfg.lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .state
+                .session_name = Some(name);
+            Ok(())
+        })
+    }
+
+    fn new_session(
+        &self,
+        _parent_session: Option<String>,
+    ) -> BoxFuture<'static, Result<bool, String>> {
+        let cancelled = self.lock_cfg().session_op_cancelled;
+        Box::pin(async move { Ok(cancelled) })
+    }
+
+    fn switch_session(&self, _session_path: String) -> BoxFuture<'static, Result<bool, String>> {
+        let cancelled = self.lock_cfg().session_op_cancelled;
+        Box::pin(async move { Ok(cancelled) })
+    }
+
+    fn fork(
+        &self,
+        _entry_id: String,
+        _position: ForkPosition,
+    ) -> BoxFuture<'static, Result<ForkOutcome, String>> {
+        let cancelled = self.lock_cfg().session_op_cancelled;
+        let text = self.lock_cfg().fork_text.clone();
+        Box::pin(async move {
+            Ok(ForkOutcome {
+                cancelled,
+                selected_text: Some(text),
+            })
+        })
+    }
+
+    fn get_entries(&self) -> BoxFuture<'static, Vec<SessionEntry>> {
+        Box::pin(async { Vec::new() })
+    }
+
+    fn get_leaf_id(&self) -> BoxFuture<'static, Option<String>> {
+        let value = self.lock_cfg().leaf_id.clone();
+        Box::pin(async move { value })
+    }
+
+    fn get_tree(&self) -> BoxFuture<'static, Vec<RpcSessionTreeNode>> {
+        Box::pin(async { Vec::new() })
+    }
+
+    fn get_fork_messages(&self) -> BoxFuture<'static, Vec<ForkMessage>> {
+        let value = self.lock_cfg().fork_messages.clone();
+        Box::pin(async move { value })
+    }
+
+    fn get_last_assistant_text(&self) -> BoxFuture<'static, Option<String>> {
+        let value = self.lock_cfg().last_assistant_text.clone();
+        Box::pin(async move { value })
+    }
+
+    fn get_messages(&self) -> BoxFuture<'static, Vec<AgentMessage>> {
+        Box::pin(async { Vec::new() })
+    }
+
+    fn get_commands(&self) -> BoxFuture<'static, Vec<RpcSlashCommand>> {
+        let value = self.lock_cfg().commands.clone();
+        Box::pin(async move { value })
+    }
+
+    fn subscribe(
+        &self,
+        listener: Arc<dyn Fn(&AgentSessionEvent) + Send + Sync>,
+    ) -> BoxUnsub {
+        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<AgentSessionEvent>();
+        *self
+            .events_tx
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(tx);
+        tokio::spawn(async move {
+            while let Some(event) = rx.recv().await {
+                listener(&event);
+            }
+        });
+        Box::new(|| {})
+    }
+
+    fn register_backpressure_hook(
+        &self,
+        _hook: Arc<dyn Fn() -> BoxFuture<'static, ()> + Send + Sync>,
+    ) -> BoxUnsub {
+        Box::new(|| {})
+    }
+
+    fn bind_extensions_rpc(
+        &self,
+        _bindings: ExtensionBindings,
+    ) -> BoxFuture<'static, Result<(), String>> {
+        Box::pin(async { Ok(()) })
+    }
+
+    fn dispose(&self) -> BoxFuture<'static, ()> {
+        self.disposed.store(true, Ordering::SeqCst);
+        Box::pin(async {})
+    }
+
+    fn set_rebind(
+        &self,
+        _callback: Option<RebindCallback>,
+    ) {
+    }
+}
+
+async fn replay_command(command: &Value, host_cfg: FakeHostConfig) -> Vec<Value> {
+    let host = FakeRpcHost::new(host_cfg);
+    let sink = BufferSink::new();
+    let sink_arc: Arc<dyn RpcSink> = Arc::new(sink.clone());
+    let (mut client, server) = tokio::io::duplex(16 * 1024);
+    let join = tokio::spawn(async move { run_rpc_loop(host, sink_arc, server).await });
+
+    let line = serde_json::to_string(command).expect("serialize command");
+    client
+        .write_all(line.as_bytes())
+        .await
+        .expect("write command");
+    client.write_all(b"\n").await.expect("write newline");
+    // Allow the prompt preflight task / event subscriber to enqueue frames
+    // before stdin EOF closes the loop.
+    tokio::time::sleep(Duration::from_millis(50)).await;
+    drop(client);
+
+    let code = join.await.expect("rpc loop join");
+    assert_eq!(code, 0, "rpc loop exit code for command {command}");
+
+    sink.stdout_lines()
+        .into_iter()
+        .map(|line| {
+            serde_json::from_str(&line)
+                .unwrap_or_else(|e| panic!("parse stdout line `{line}`: {e}"))
+        })
+        .collect()
+}
+
+fn load_ts_goldens() -> Value {
+    // Prefer a live Bun replay when available; fall back to checked-in goldens.
+    let script = fixtures_dir().join("ts-replay.ts");
+    let goldens_path = fixtures_dir().join("ts-goldens.json");
+    match Command::new("bun").arg(&script).output() {
+        Ok(output) if output.status.success() => {
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            serde_json::from_str(stdout.trim())
+                .unwrap_or_else(|e| panic!("parse bun ts-replay stdout: {e}"))
+        }
+        Ok(output) => {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            let fallback = std::fs::read_to_string(&goldens_path).unwrap_or_else(|e| {
+                panic!(
+                    "bun ts-replay failed ({stderr}) and goldens missing: {e}"
+                )
+            });
+            serde_json::from_str(&fallback).expect("parse checked-in ts-goldens.json")
+        }
+        Err(_) => {
+            let fallback = std::fs::read_to_string(&goldens_path)
+                .unwrap_or_else(|e| panic!("read {}: {e}", goldens_path.display()));
+            serde_json::from_str(&fallback).expect("parse checked-in ts-goldens.json")
+        }
+    }
+}
+
+#[tokio::test]
+async fn rpc_parity_replays_all_31_commands() {
+    let commands = load_json("commands.json");
+    let host_state = load_json("host-state.json");
+    let cases = commands
+        .as_array()
+        .expect("commands.json must be an array");
+    assert_eq!(
+        cases.len(),
+        31,
+        "fixtures/rpc/commands.json must list all 31 RpcCommand discriminants"
+    );
+
+    let ts = load_ts_goldens();
+    let ts_cases = ts["cases"]
+        .as_array()
+        .expect("ts goldens cases array");
+    assert_eq!(ts_cases.len(), 31, "TypeScript harness must emit 31 cases");
+
+    let mut seen = std::collections::BTreeSet::new();
+
+    for (idx, case) in cases.iter().enumerate() {
+        let name = case["name"].as_str().expect("case.name");
+        let command = &case["command"];
+        let command_type = command["type"].as_str().expect("command.type");
+        assert!(
+            seen.insert(command_type.to_owned()),
+            "duplicate command type fixture: {command_type}"
+        );
+
+        let host_cfg = FakeHostConfig::from_fixture(&host_state);
+        let rust_frames = replay_command(command, host_cfg).await;
+        assert!(
+            !rust_frames.is_empty(),
+            "Rust produced no frames for {name}"
+        );
+
+        // Prompt preflight ordering: response frame must precede agent events.
+        if command_type == "prompt" {
+            assert!(
+                rust_frames.len() >= 2,
+                "prompt must emit response + event, got {rust_frames:?}"
+            );
+            assert_eq!(
+                rust_frames[0]["type"], "response",
+                "prompt first frame must be response"
+            );
+            assert_eq!(rust_frames[0]["command"], "prompt");
+            assert_eq!(rust_frames[0]["success"], true);
+            assert_eq!(
+                rust_frames[1]["type"], "turn_start",
+                "prompt second frame must be turn_start event"
+            );
+        }
+
+        let ts_case = ts_cases
+            .iter()
+            .find(|c| c["name"] == name)
+            .unwrap_or_else(|| panic!("missing TS golden for case {name}"));
+        let ts_frames = ts_case["frames"]
+            .as_array()
+            .expect("ts frames")
+            .clone();
+
+        let rust_norm = normalize_frames(&rust_frames);
+        let ts_norm = normalize_frames(&ts_frames);
+        assert_eq!(
+            rust_norm, ts_norm,
+            "RPC parity mismatch for case #{idx} `{name}` ({command_type})\nRust: {}\nTS:   {}",
+            serde_json::to_string_pretty(&rust_norm).unwrap_or_default(),
+            serde_json::to_string_pretty(&ts_norm).unwrap_or_default()
+        );
+    }
+
+    assert_eq!(seen.len(), 31, "expected 31 distinct command types");
+}
+
+#[test]
+fn rpc_command_fixture_covers_protocol_surface() {
+    let commands = load_json("commands.json");
+    let cases = commands.as_array().expect("array");
+    let expected = [
+        "prompt",
+        "steer",
+        "follow_up",
+        "abort",
+        "new_session",
+        "get_state",
+        "set_model",
+        "cycle_model",
+        "get_available_models",
+        "set_thinking_level",
+        "cycle_thinking_level",
+        "set_steering_mode",
+        "set_follow_up_mode",
+        "compact",
+        "set_auto_compaction",
+        "set_auto_retry",
+        "abort_retry",
+        "bash",
+        "abort_bash",
+        "get_session_stats",
+        "export_html",
+        "switch_session",
+        "fork",
+        "clone",
+        "get_fork_messages",
+        "get_entries",
+        "get_tree",
+        "get_last_assistant_text",
+        "set_session_name",
+        "get_messages",
+        "get_commands",
+    ];
+    let got: Vec<&str> = cases
+        .iter()
+        .map(|c| c["command"]["type"].as_str().expect("type"))
+        .collect();
+    assert_eq!(got, expected);
+}