@webinson/peer 0.4.15 → 0.4.17

package/mod/codex/client/src/band.rs

@@ -0,0 +1,469 @@
+//! Peer controls render in the composer; every action runs locally, outside the model.
+
+use super::*;
+use codex_config::peer_thread_mark::{self, Mode};
+use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
+use ratatui::text::Span;
+use serde::Deserialize;
+use std::cell::Cell;
+
+pub(crate) const TITLE_MARK: &str = "● Peer · ";
+pub(crate) const THREADS_VIEW: &str = "peer-threads";
+
+#[derive(Debug, Clone)]
+pub(crate) enum PeerAction {
+    Refresh,
+    Start(Option<UserMessage>),
+    Stop,
+    Elephant,
+    Jellyfish,
+    List,
+    ReloadList,
+    Thread,
+    All(String),
+    Search(String),
+}
+
+impl PeerAction {
+    pub(crate) fn command(&self) -> &'static str {
+        match self {
+            Self::Refresh => "status",
+            Self::Start(_) => "start",
+            Self::Stop => "stop",
+            Self::Elephant => "elephant",
+            Self::Jellyfish => "jellyfish",
+            Self::List | Self::ReloadList => "list",
+            Self::Thread => "thread",
+            Self::All(_) | Self::Search(_) => "all",
+        }
+    }
+
+    pub(crate) fn changes_mode(&self) -> bool {
+        matches!(
+            self,
+            Self::Start(_) | Self::Stop | Self::Elephant | Self::Jellyfish
+        )
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct PeerReply {
+    pub output: Option<String>,
+    pub memory_count: Option<u32>,
+    pub memory_page: Option<PeerMemoryPage>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct PeerMemoryPage {
+    text: String,
+    here: bool,
+    sort: String,
+    total: usize,
+    page: usize,
+    pages: usize,
+    rows: Vec<PeerMemoryRow>,
+}
+
+#[derive(Debug, Deserialize)]
+struct PeerMemoryRow {
+    title: String,
+    repo: String,
+    #[serde(rename = "type")]
+    kind: String,
+    at: String,
+    lines: Vec<String>,
+    uri: String,
+}
+
+fn memory_query(text: &str, here: bool, sort: &str, page: usize) -> String {
+    let order = match sort {
+        "new" => "--newest",
+        "old" => "--oldest",
+        _ => "",
+    };
+    [
+        text.to_string(),
+        if here { "here".into() } else { String::new() },
+        order.into(),
+        format!("page {page}"),
+    ]
+    .into_iter()
+    .filter(|part| !part.is_empty())
+    .collect::<Vec<_>>()
+    .join(" ")
+}
+
+#[derive(Default)]
+pub(super) struct PeerBandState {
+    mode: Mode,
+    memory_count: Option<u32>,
+    bounds: Cell<Option<Rect>>,
+}
+
+pub(super) struct PeerBand<'a> {
+    state: &'a PeerBandState,
+}
+
+fn band_labels(width: u16, count: Option<u32>, mode: Mode) -> [String; 4] {
+    let count = count.map_or_else(|| "–".to_string(), |value| value.to_string());
+    let active = if mode == Mode::Inactive {
+        "○ Inactive"
+    } else {
+        "● Active"
+    };
+    if width >= 66 {
+        [
+            format!("{count} memories"),
+            "Use Elephant".to_string(),
+            "Use Jellyfish".to_string(),
+            active.to_string(),
+        ]
+    } else if width >= 53 {
+        [
+            format!("{count} mem"),
+            "Elephant".to_string(),
+            "Jellyfish".to_string(),
+            active.to_string(),
+        ]
+    } else {
+        [
+            count,
+            "Elephant".into(),
+            "Jellyfish".into(),
+            if mode == Mode::Inactive {
+                "○".into()
+            } else {
+                "●".into()
+            },
+        ]
+    }
+}
+
+impl Renderable for PeerBand<'_> {
+    fn render(&self, area: Rect, buf: &mut Buffer) {
+        self.state.bounds.set(Some(area));
+        let [count, elephant, jellyfish, active] =
+            band_labels(area.width, self.state.memory_count, self.state.mode);
+        let accent = crate::style::accent_style();
+        let elephant = if self.state.mode == Mode::Elephant {
+            Span::styled(elephant, accent).bold()
+        } else {
+            elephant.into()
+        };
+        let jellyfish = if self.state.mode == Mode::Jellyfish {
+            Span::styled(jellyfish, accent).bold()
+        } else {
+            jellyfish.into()
+        };
+        let line = Line::from(vec![
+            "  ".into(),
+            Span::styled(count, accent),
+            "  ·  ".dim(),
+            elephant,
+            "  ·  ".dim(),
+            jellyfish,
+            "  ·  ".dim(),
+            active.dim(),
+        ]);
+        Renderable::render(&Paragraph::new(line), area, buf);
+    }
+
+    fn desired_height(&self, width: u16) -> u16 {
+        u16::from(width >= 35)
+    }
+}
+
+impl ChatWidget {
+    pub(crate) fn peer_available(&self) -> bool {
+        self.remote_connection.is_none()
+            && !self.active_side_conversation
+            && !self.blocks_direct_input
+            && peer_thread_mark::home().is_some_and(|home| home.join("config.json").is_file())
+    }
+
+    pub(super) fn peer_band(&self) -> Option<PeerBand<'_>> {
+        self.peer_mark.bounds.set(None);
+        (self.thread_id.is_some() && self.peer_available() && !self.bottom_pane.has_active_view())
+            .then_some(PeerBand {
+                state: &self.peer_mark,
+            })
+    }
+
+    pub(crate) fn handle_peer_mouse(&mut self, mouse: MouseEvent) -> bool {
+        if mouse.kind != MouseEventKind::Down(MouseButton::Left)
+            || !self.peer_available()
+            || self.bottom_pane.has_active_view()
+            || self.quick_dial_menu
+            || self.safety_recourse.is_some()
+        {
+            return false;
+        }
+        let Some(area) = self.peer_mark.bounds.get() else {
+            return false;
+        };
+        if mouse.row != area.y || area.height == 0 || mouse.column >= area.right() {
+            return false;
+        }
+        let mut x = area.x.saturating_add(2);
+        let labels = band_labels(area.width, self.peer_mark.memory_count, self.peer_mark.mode);
+        for (label, action) in labels.into_iter().zip([
+            PeerAction::Thread,
+            PeerAction::Elephant,
+            PeerAction::Jellyfish,
+            PeerAction::List,
+        ]) {
+            let end = x.saturating_add(Line::from(label).width() as u16);
+            if (x..end).contains(&mouse.column) {
+                self.request_peer_action(action);
+                return true;
+            }
+            x = end.saturating_add(5);
+        }
+        false
+    }
+
+    pub(super) fn request_peer_action(&mut self, action: PeerAction) {
+        if !self.peer_available() {
+            if !matches!(action, PeerAction::Refresh) {
+                self.add_error_message("Peer is unavailable here. Run `peer install --codex` and start the Peer Codex client.".into());
+            }
+            return;
+        }
+        if let Some(thread_id) = self.thread_id {
+            self.app_event_tx
+                .send(AppEvent::PeerThreadMark { thread_id, action });
+        }
+    }
+
+    pub(super) fn reset_peer_band(&mut self) {
+        self.peer_mark = PeerBandState::default();
+        self.sync_peer_band(/*memory_count*/ None);
+        self.request_peer_action(PeerAction::Refresh);
+    }
+
+    pub(super) fn stop_peer_before_clear(&mut self) {
+        if self.peer_mark.mode != Mode::Inactive {
+            self.request_peer_action(PeerAction::Stop);
+        }
+    }
+
+    pub(super) fn restore_peer_title(&mut self) {
+        if self.peer_available()
+            && self.peer_mark.mode != Mode::Inactive
+            && let Some(title) = &self.thread_name
+            && !title.starts_with(TITLE_MARK)
+        {
+            self.submit_op(AppCommand::set_thread_name(format!("{TITLE_MARK}{title}")));
+        }
+    }
+
+    pub(crate) fn sync_peer_band(&mut self, memory_count: Option<u32>) {
+        if let Some(id) = self.thread_id {
+            self.peer_mark.mode = peer_thread_mark::mode(&id.to_string());
+        }
+        if memory_count.is_some() {
+            self.peer_mark.memory_count = memory_count;
+        }
+        self.request_redraw();
+    }
+
+    pub(crate) fn peer_list_open(&self) -> bool {
+        self.bottom_pane
+            .selected_index_for_active_view(THREADS_VIEW)
+            .is_some()
+    }
+
+    pub(crate) fn show_peer_result(
+        &mut self,
+        title: &str,
+        view_id: &'static str,
+        text: &str,
+        replace: bool,
+    ) {
+        let items = text
+            .lines()
+            .filter(|line| !line.trim().is_empty())
+            .map(|line| SelectionItem {
+                name: line.chars().filter(|c| !c.is_control()).collect(),
+                ..Default::default()
+            })
+            .collect();
+        let params = SelectionViewParams {
+            title: Some(title.to_string()),
+            view_id: Some(view_id),
+            items,
+            auto_number_shortcuts: false,
+            is_searchable: true,
+            ..SelectionViewParams::picker()
+        };
+        if replace {
+            self.bottom_pane
+                .replace_selection_view_if_active(view_id, params);
+        } else {
+            self.show_selection_view(params);
+        }
+    }
+
+    pub(crate) fn show_peer_search(&mut self, thread_id: ThreadId, query: String) {
+        let tx = self.app_event_tx.clone();
+        self.bottom_pane.show_text_prompt(CustomPromptView::new(
+            "Search your memories".into(),
+            "Words, quoted phrases, here, --newest, --oldest or page N".into(),
+            query,
+            None,
+            Box::new(move |query| {
+                tx.send(AppEvent::PeerThreadMark {
+                    thread_id,
+                    action: PeerAction::All(query),
+                })
+            }),
+        ));
+    }
+
+    pub(crate) fn show_peer_memories(&mut self, thread_id: ThreadId, page: PeerMemoryPage) {
+        let action_item = |name: &str, action: PeerAction| SelectionItem {
+            name: name.into(),
+            actions: vec![Box::new(move |tx| {
+                tx.send(AppEvent::PeerThreadMark {
+                    thread_id,
+                    action: action.clone(),
+                })
+            })],
+            dismiss_on_select: true,
+            ..Default::default()
+        };
+        let query = |here, sort, number| memory_query(&page.text, here, sort, number);
+        let (sort_label, next_sort) = match page.sort.as_str() {
+            "new" => ("Order: newest first", "old"),
+            "old" => ("Order: oldest first", ""),
+            _ => ("Order: OpenViking", "new"),
+        };
+        let mut items = vec![
+            action_item(
+                "Search your memories…",
+                PeerAction::Search(query(page.here, &page.sort, 1)),
+            ),
+            action_item(
+                if page.here {
+                    "Repository: this one"
+                } else {
+                    "Repository: all"
+                },
+                PeerAction::All(query(!page.here, &page.sort, 1)),
+            ),
+            action_item(sort_label, PeerAction::All(query(page.here, next_sort, 1))),
+        ];
+        if page.page > 1 {
+            items.push(action_item(
+                "Previous page",
+                PeerAction::All(query(page.here, &page.sort, page.page - 1)),
+            ));
+        }
+        if page.page < page.pages {
+            items.push(action_item(
+                "Next page",
+                PeerAction::All(query(page.here, &page.sort, page.page + 1)),
+            ));
+        }
+        let plain = |text: &str| text.chars().filter(|c| !c.is_control()).collect::<String>();
+        items.extend(page.rows.into_iter().map(|row| SelectionItem {
+            name: plain(&row.title),
+            description: Some(plain(&format!("{} · {} · {}", row.repo, row.kind, row.at))),
+            selected_description: Some(format!(
+                "{}\n{}",
+                plain(&row.lines.join(" / ")),
+                plain(&row.uri)
+            )),
+            ..Default::default()
+        }));
+        self.show_selection_view(SelectionViewParams {
+            title: Some("Your memories".into()),
+            subtitle: Some(format!(
+                "{} memories · page {} of {}",
+                page.total, page.page, page.pages
+            )),
+            items,
+            auto_number_shortcuts: false,
+            ..SelectionViewParams::picker()
+        });
+    }
+
+    pub(super) fn open_peer_modes(&mut self) {
+        let Some(thread_id) = self.thread_id.filter(|_| self.peer_available()) else {
+            self.add_error_message(
+                "Run `peer install --codex` to set up Peer in this client.".into(),
+            );
+            return;
+        };
+        let mut items = Vec::new();
+        for (name, description, mode, action) in [
+            (
+                "Use Elephant",
+                "Share this thread and use OpenViking and Codex memory.",
+                Mode::Elephant,
+                PeerAction::Elephant,
+            ),
+            (
+                "Use Jellyfish",
+                "Share this thread without memory. Instructions stay.",
+                Mode::Jellyfish,
+                PeerAction::Jellyfish,
+            ),
+            (
+                "Inactive",
+                "Stop sharing and keep Codex's own memory.",
+                Mode::Inactive,
+                PeerAction::Stop,
+            ),
+        ] {
+            let action: super::SelectionAction = Box::new(move |tx| {
+                tx.send(AppEvent::PeerThreadMark {
+                    thread_id,
+                    action: action.clone(),
+                });
+            });
+            items.push(SelectionItem {
+                name: name.to_string(),
+                description: Some(description.to_string()),
+                is_current: self.peer_mark.mode == mode,
+                actions: vec![action],
+                dismiss_on_select: true,
+                ..Default::default()
+            });
+        }
+        self.show_selection_view(SelectionViewParams {
+            title: Some("Peer memory mode".into()),
+            items,
+            ..SelectionViewParams::picker()
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_band_shows_the_memory_count_and_selected_mode() {
+        let state = PeerBandState {
+            mode: Mode::Jellyfish,
+            memory_count: Some(7),
+            ..Default::default()
+        };
+        let area = Rect::new(0, 0, 80, 1);
+        let mut buf = Buffer::empty(area);
+        PeerBand { state: &state }.render(area, &mut buf);
+        let line: String = buf.content().iter().map(|cell| cell.symbol()).collect();
+        assert!(line.contains("7 memories"));
+        assert!(line.contains("Use Elephant"));
+        assert!(line.contains("Use Jellyfish"));
+        assert!(line.contains("● Active"));
+        let selected = line.find("Use Jellyfish").expect("selected label");
+        assert!(
+            buf.content()[selected]
+                .modifier
+                .contains(ratatui::style::Modifier::BOLD)
+        );
+    }
+}

package/mod/codex/client/src/openviking.rs

@@ -0,0 +1,110 @@
+//! OpenViking reads a projection of the opted-in turns, including when it sweeps old sessions.
+
+use std::fs;
+use std::io::{BufRead, BufReader, Write};
+use std::path::Path;
+
+use codex_config::peer_thread_mark::{self, Mode, Window};
+use serde_json::Value;
+
+pub(super) fn is_openviking(root: &str) -> bool {
+    Path::new(root).ancestors().take(2).any(|dir| {
+        dir.file_name()
+            .is_some_and(|name| name == "openviking-memory")
+    })
+}
+
+pub(super) fn project(home: &Path, mut input: Value) -> Value {
+    let session = input["session_id"].as_str().unwrap_or_default();
+    let windows = peer_thread_mark::windows(home, session);
+    let projected = if peer_thread_mark::mode_at(home, session) == Mode::Elephant
+        && !windows.is_empty()
+        && let Some(transcript) = input["transcript_path"].as_str()
+    {
+        let output = home
+            .join("codex-capture/rollouts")
+            .join(format!("codex-{session}.jsonl"));
+        project_file(Path::new(transcript), &output, &windows)
+            .ok()
+            .map(|()| output)
+    } else {
+        None
+    };
+    input["transcript_path"] = projected.map_or(Value::Null, |path| {
+        Value::String(path.to_string_lossy().into_owned())
+    });
+    if let Some(path) = input.get_mut("agent_transcript_path") {
+        *path = Value::Null;
+    }
+    input
+}
+
+fn project_file(source: &Path, output: &Path, windows: &[Window]) -> std::io::Result<()> {
+    let directory = output.parent().expect("projection directory");
+    fs::create_dir_all(directory)?;
+    let mut projected = tempfile::NamedTempFile::new_in(directory)?;
+    for (index, line) in BufReader::new(fs::File::open(source)?).lines().enumerate() {
+        let line = line?;
+        let Ok(row) = serde_json::from_str::<Value>(&line) else {
+            continue;
+        };
+        let header = index == 0 && row["type"].as_str() == Some("session_meta");
+        let allowed = row["timestamp"]
+            .as_str()
+            .and_then(|at| chrono::DateTime::parse_from_rfc3339(at).ok())
+            .is_some_and(|at| {
+                peer_thread_mark::contains(windows, Mode::Elephant, at.timestamp_millis())
+            });
+        if header || allowed {
+            writeln!(projected, "{line}")?;
+        }
+    }
+    projected.persist(output)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn projection_keeps_elephant_turns_across_a_pause() -> std::io::Result<()> {
+        let dir = tempfile::tempdir()?;
+        let source = dir.path().join("full.jsonl");
+        let output = dir.path().join("elephant.jsonl");
+        fs::write(
+            &source,
+            concat!(
+                "{\"type\":\"session_meta\",\"timestamp\":\"1970-01-01T00:00:00Z\"}\n",
+                "{\"timestamp\":\"1970-01-01T00:00:01Z\",\"text\":\"before opt-in\"}\n",
+                "{\"timestamp\":\"1970-01-01T00:00:02Z\",\"text\":\"first elephant turn\"}\n",
+                "{\"timestamp\":\"1970-01-01T00:00:03Z\",\"text\":\"private jellyfish\"}\n",
+                "{\"timestamp\":\"1970-01-01T00:00:04Z\",\"text\":\"second elephant turn\"}\n",
+            ),
+        )?;
+        let windows = [
+            Window {
+                mode: Mode::Elephant,
+                start: 2000,
+                end: Some(3000),
+            },
+            Window {
+                mode: Mode::Jellyfish,
+                start: 3000,
+                end: Some(4000),
+            },
+            Window {
+                mode: Mode::Elephant,
+                start: 4000,
+                end: None,
+            },
+        ];
+        project_file(&source, &output, &windows)?;
+        let filtered = fs::read_to_string(output)?;
+        assert!(filtered.contains("first elephant turn"));
+        assert!(filtered.contains("second elephant turn"));
+        assert!(!filtered.contains("before opt-in"));
+        assert!(!filtered.contains("private jellyfish"));
+        Ok(())
+    }
+}

package/mod/codex/client/src/policy.rs

@@ -0,0 +1,132 @@
+//! Local Peer state shared by the terminal, memory extension and hook runtime.
+
+use std::env;
+use std::fs;
+use std::path::Path;
+use std::path::PathBuf;
+
+use serde::Deserialize;
+
+pub const OPENVIKING_PLUGIN: &str = "openviking-memory@openviking";
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum Mode {
+    #[default]
+    Inactive,
+    Elephant,
+    Jellyfish,
+}
+
+#[derive(Deserialize)]
+struct Marker {
+    mode: Mode,
+    workspace: String,
+}
+
+#[derive(Deserialize)]
+pub struct Window {
+    pub mode: Mode,
+    pub start: i64,
+    pub end: Option<i64>,
+}
+
+pub fn home() -> Option<PathBuf> {
+    if env::var("PEER_CODEX_THREAD_MARK").as_deref() != Ok("1") {
+        return None;
+    }
+    let home = env::var_os("PEER_HOME")
+        .filter(|value| !value.is_empty())
+        .map(PathBuf::from)
+        .or_else(|| env::home_dir().map(|path| path.join(".peer")))?;
+    home.join("codex-cli.json").is_file().then_some(home)
+}
+
+fn valid_id(id: &str) -> bool {
+    !id.is_empty()
+        && id.len() <= 114
+        && id
+            .bytes()
+            .all(|byte| byte.is_ascii_alphanumeric() || b"-_.".contains(&byte))
+}
+
+pub fn mode_at(home: &Path, thread_id: &str) -> Mode {
+    if !valid_id(thread_id) {
+        return Mode::Inactive;
+    }
+    fs::read(home.join("sessions").join(format!("codex-{thread_id}")))
+        .ok()
+        .and_then(|bytes| serde_json::from_slice::<Marker>(&bytes).ok())
+        .filter(|mark| !mark.workspace.is_empty())
+        .map_or(Mode::Inactive, |mark| mark.mode)
+}
+
+pub fn mode(thread_id: &str) -> Mode {
+    home().map_or(Mode::Inactive, |home| mode_at(&home, thread_id))
+}
+
+pub fn disabled_plugins(thread_id: &str, original: &[String]) -> Vec<String> {
+    let mut disabled = original.to_vec();
+    if let Some(home) = home()
+        && mode_at(&home, thread_id) != Mode::Elephant
+        && !disabled.iter().any(|id| id == OPENVIKING_PLUGIN)
+    {
+        disabled.push(OPENVIKING_PLUGIN.to_string());
+    }
+    disabled
+}
+
+pub fn windows(home: &Path, thread_id: &str) -> Vec<Window> {
+    if !valid_id(thread_id) {
+        return Vec::new();
+    }
+    fs::read(
+        home.join("codex-capture")
+            .join(format!("codex-{thread_id}.json")),
+    )
+    .ok()
+    .and_then(|bytes| serde_json::from_slice(&bytes).ok())
+    .unwrap_or_default()
+}
+
+pub fn contains(windows: &[Window], mode: Mode, timestamp_ms: i64) -> bool {
+    windows.iter().any(|window| {
+        window.mode == mode
+            && window.start <= timestamp_ms
+            && window.end.is_none_or(|end| timestamp_ms < end)
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_mode_owns_only_the_rows_inside_its_window() {
+        let windows = [
+            Window {
+                mode: Mode::Elephant,
+                start: 3,
+                end: Some(6),
+            },
+            Window {
+                mode: Mode::Jellyfish,
+                start: 6,
+                end: Some(9),
+            },
+            Window {
+                mode: Mode::Elephant,
+                start: 15,
+                end: None,
+            },
+        ];
+        let captured: Vec<_> = (1..18)
+            .filter(|ts| contains(&windows, Mode::Elephant, *ts))
+            .collect();
+        assert_eq!(captured, [3, 4, 5, 15, 16, 17]);
+        let jellyfish: Vec<_> = (1..18)
+            .filter(|ts| contains(&windows, Mode::Jellyfish, *ts))
+            .collect();
+        assert_eq!(jellyfish, [6, 7, 8]);
+    }
+}