@masyv/relay 0.1.0

package/core/src/agents/openai.rs

@@ -0,0 +1,85 @@
+//! OpenAI GPT agent adapter.
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult, OpenAIConfig};
+use anyhow::Result;
+
+pub struct OpenAIAgent {
+    api_key: Option<String>,
+    model: String,
+}
+
+impl OpenAIAgent {
+    pub fn new(config: &OpenAIConfig) -> Self {
+        let api_key = config.api_key.clone()
+            .or_else(|| std::env::var("OPENAI_API_KEY").ok());
+        Self {
+            api_key,
+            model: config.model.clone(),
+        }
+    }
+}
+
+impl Agent for OpenAIAgent {
+    fn name(&self) -> &str { "openai" }
+
+    fn check_available(&self) -> AgentStatus {
+        match &self.api_key {
+            Some(_) => AgentStatus {
+                name: "openai".into(),
+                available: true,
+                reason: format!("API key configured, model: {}", self.model),
+                version: Some(self.model.clone()),
+            },
+            None => AgentStatus {
+                name: "openai".into(),
+                available: false,
+                reason: "No API key. Set OPENAI_API_KEY env var or add to config.toml".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, _project_dir: &str) -> Result<HandoffResult> {
+        let api_key = self.api_key.as_ref()
+            .ok_or_else(|| anyhow::anyhow!("No OpenAI API key"))?;
+
+        let body = serde_json::json!({
+            "model": self.model,
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are a coding assistant picking up work from a Claude Code session that hit its rate limit. Follow the handoff instructions precisely. Be efficient and direct — the user has a deadline."
+                },
+                {
+                    "role": "user",
+                    "content": handoff_prompt
+                }
+            ],
+            "max_tokens": 4096
+        });
+
+        let resp = ureq::post("https://api.openai.com/v1/chat/completions")
+            .set("Authorization", &format!("Bearer {api_key}"))
+            .set("Content-Type", "application/json")
+            .send_json(&body)?;
+
+        let resp_json: serde_json::Value = resp.into_json()?;
+        let text = resp_json
+            .get("choices")
+            .and_then(|c| c.get(0))
+            .and_then(|c| c.get("message"))
+            .and_then(|m| m.get("content"))
+            .and_then(|c| c.as_str())
+            .unwrap_or("(no response)");
+
+        println!("{text}");
+
+        Ok(HandoffResult {
+            agent: "openai".into(),
+            success: true,
+            message: format!("OpenAI ({}) responded", self.model),
+            handoff_file: None,
+        })
+    }
+}

package/core/src/capture/git.rs

@@ -0,0 +1,66 @@
+//! Capture git state: branch, diff, status, recent commits.
+
+use crate::GitState;
+use anyhow::{Context, Result};
+use std::path::Path;
+use std::process::Command;
+
+pub fn capture_git_state(project_dir: &Path) -> Result<GitState> {
+    let branch = run_git(project_dir, &["branch", "--show-current"])?
+        .trim()
+        .to_string();
+
+    let status = run_git(project_dir, &["status", "--short"])?;
+    let uncommitted_files: Vec<String> = status
+        .lines()
+        .map(|l| l.trim().to_string())
+        .filter(|l| !l.is_empty())
+        .collect();
+
+    let status_summary = if uncommitted_files.is_empty() {
+        "Clean working tree".to_string()
+    } else {
+        format!("{} uncommitted changes", uncommitted_files.len())
+    };
+
+    // Recent commits (last 5, one-line)
+    let log = run_git(
+        project_dir,
+        &["log", "--oneline", "-5", "--no-decorate"],
+    )
+    .unwrap_or_default();
+    let recent_commits: Vec<String> = log
+        .lines()
+        .map(|l| l.trim().to_string())
+        .filter(|l| !l.is_empty())
+        .collect();
+
+    // Diff summary (stat, not full diff — keeps handoff small)
+    let diff_summary = run_git(project_dir, &["diff", "--stat", "HEAD"])
+        .unwrap_or_default()
+        .trim()
+        .to_string();
+
+    Ok(GitState {
+        branch,
+        status_summary,
+        recent_commits,
+        diff_summary,
+        uncommitted_files,
+    })
+}
+
+fn run_git(dir: &Path, args: &[&str]) -> Result<String> {
+    let output = Command::new("git")
+        .current_dir(dir)
+        .args(args)
+        .output()
+        .context("failed to run git")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        anyhow::bail!("git {} failed: {}", args.join(" "), stderr.trim());
+    }
+
+    Ok(String::from_utf8_lossy(&output.stdout).to_string())
+}

package/core/src/capture/mod.rs

@@ -0,0 +1,41 @@
+pub mod git;
+pub mod session;
+pub mod todos;
+
+use crate::SessionSnapshot;
+use anyhow::Result;
+use std::path::Path;
+
+/// Capture a full session snapshot from the current working directory.
+pub fn capture_snapshot(
+    project_dir: &Path,
+    deadline: Option<&str>,
+) -> Result<SessionSnapshot> {
+    let git_state = git::capture_git_state(project_dir).ok();
+
+    // Try to read Claude session state
+    let session_info = session::read_latest_session(project_dir);
+
+    // Try to read todo state
+    let todos = todos::read_todos(project_dir);
+
+    let recent_files = git_state
+        .as_ref()
+        .map(|g| g.uncommitted_files.clone())
+        .unwrap_or_default();
+
+    let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
+
+    Ok(SessionSnapshot {
+        current_task: session_info.current_task,
+        todos,
+        decisions: session_info.decisions,
+        last_error: session_info.last_error,
+        last_output: session_info.last_output,
+        git_state,
+        project_dir: project_dir.to_string_lossy().to_string(),
+        recent_files,
+        timestamp,
+        deadline: deadline.map(String::from),
+    })
+}

package/core/src/capture/session.rs

@@ -0,0 +1,217 @@
+//! Read Claude Code session state from .jsonl transcript files.
+
+use std::path::Path;
+
+/// Extracted session info from Claude's transcript.
+pub struct SessionInfo {
+    pub current_task: String,
+    pub decisions: Vec<String>,
+    pub last_error: Option<String>,
+    pub last_output: Option<String>,
+}
+
+/// Read the latest Claude session transcript and extract state.
+pub fn read_latest_session(project_dir: &Path) -> SessionInfo {
+    // Claude stores transcripts in ~/.claude/projects/<project_hash>/<session>.jsonl
+    // Try to find and parse the latest one
+
+    let claude_dir = find_claude_project_dir(project_dir);
+
+    if let Some(dir) = claude_dir {
+        if let Some(latest) = find_latest_jsonl(&dir) {
+            return parse_session_transcript(&latest);
+        }
+    }
+
+    // Fallback: infer from git state
+    SessionInfo {
+        current_task: infer_task_from_git(project_dir),
+        decisions: Vec::new(),
+        last_error: None,
+        last_output: None,
+    }
+}
+
+fn find_claude_project_dir(project_dir: &Path) -> Option<std::path::PathBuf> {
+    let home = std::env::var("HOME").ok()?;
+    let claude_projects = std::path::PathBuf::from(&home).join(".claude/projects");
+    if !claude_projects.exists() {
+        return None;
+    }
+
+    // Claude encodes the project path: /Users/user/myproject -> -Users-user-myproject
+    let proj_str = project_dir.to_string_lossy().replace('/', "-");
+    let candidate = claude_projects.join(&proj_str);
+    if candidate.exists() {
+        return Some(candidate);
+    }
+
+    // Try matching by suffix
+    if let Ok(entries) = std::fs::read_dir(&claude_projects) {
+        let dir_name = project_dir.file_name()?.to_string_lossy();
+        for entry in entries.flatten() {
+            let name = entry.file_name().to_string_lossy().to_string();
+            if name.ends_with(&*dir_name) && entry.path().is_dir() {
+                return Some(entry.path());
+            }
+        }
+    }
+
+    None
+}
+
+fn find_latest_jsonl(dir: &std::path::Path) -> Option<std::path::PathBuf> {
+    let mut newest: Option<(std::path::PathBuf, std::time::SystemTime)> = None;
+    if let Ok(entries) = std::fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().map(|e| e == "jsonl").unwrap_or(false) {
+                if let Ok(meta) = path.metadata() {
+                    if let Ok(modified) = meta.modified() {
+                        if newest.as_ref().map_or(true, |(_, t)| modified > *t) {
+                            newest = Some((path, modified));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    newest.map(|(p, _)| p)
+}
+
+fn parse_session_transcript(path: &std::path::Path) -> SessionInfo {
+    let content = match std::fs::read_to_string(path) {
+        Ok(c) => c,
+        Err(_) => return default_session_info(),
+    };
+
+    let mut current_task = String::new();
+    let mut decisions = Vec::new();
+    let mut last_error = None;
+    let mut last_output = None;
+
+    // Read last 200 lines of the JSONL for efficiency
+    let lines: Vec<&str> = content.lines().collect();
+    let start = lines.len().saturating_sub(200);
+
+    for line in &lines[start..] {
+        let Ok(val) = serde_json::from_str::<serde_json::Value>(line) else { continue };
+
+        // Extract user messages for task context
+        if val.get("type").and_then(|v| v.as_str()) == Some("human") {
+            if let Some(msg) = val.get("message").and_then(|m| {
+                m.get("content").and_then(|c| {
+                    if let Some(s) = c.as_str() {
+                        Some(s.to_string())
+                    } else if let Some(arr) = c.as_array() {
+                        arr.iter()
+                            .filter_map(|item| item.get("text").and_then(|t| t.as_str()))
+                            .last()
+                            .map(String::from)
+                    } else {
+                        None
+                    }
+                })
+            }) {
+                // Keep the last substantive user message as current task
+                if msg.len() > 10 && !msg.starts_with('/') {
+                    current_task = if msg.len() > 500 {
+                        format!("{}...", &msg[..500])
+                    } else {
+                        msg
+                    };
+                }
+            }
+        }
+
+        // Extract assistant tool use for last output
+        if val.get("type").and_then(|v| v.as_str()) == Some("assistant") {
+            if let Some(content) = val.get("message").and_then(|m| m.get("content")) {
+                if let Some(arr) = content.as_array() {
+                    for item in arr {
+                        // Look for tool results
+                        if item.get("type").and_then(|t| t.as_str()) == Some("tool_result") {
+                            if let Some(output) = item.get("content").and_then(|c| c.as_str()) {
+                                // Check for errors
+                                let lower = output.to_lowercase();
+                                if lower.contains("error") || lower.contains("failed") || lower.contains("panic") {
+                                    last_error = Some(truncate(output, 500));
+                                }
+                                last_output = Some(truncate(output, 500));
+                            }
+                        }
+                        // Look for text content with decisions
+                        if item.get("type").and_then(|t| t.as_str()) == Some("text") {
+                            if let Some(text) = item.get("text").and_then(|t| t.as_str()) {
+                                // Extract lines that look like decisions
+                                for line in text.lines() {
+                                    let trimmed = line.trim();
+                                    if (trimmed.starts_with("I'll use") ||
+                                        trimmed.starts_with("I chose") ||
+                                        trimmed.starts_with("Decision:") ||
+                                        trimmed.starts_with("Using ") ||
+                                        trimmed.starts_with("Approach:"))
+                                        && trimmed.len() > 15
+                                    {
+                                        decisions.push(truncate(trimmed, 200));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if current_task.is_empty() {
+        current_task = "Could not determine current task from session transcript".into();
+    }
+
+    // Deduplicate and limit decisions
+    decisions.dedup();
+    decisions.truncate(10);
+
+    SessionInfo {
+        current_task,
+        decisions,
+        last_error,
+        last_output,
+    }
+}
+
+fn infer_task_from_git(project_dir: &Path) -> String {
+    // Infer from recent commit messages
+    let output = std::process::Command::new("git")
+        .current_dir(project_dir)
+        .args(["log", "--oneline", "-1", "--no-decorate"])
+        .output();
+
+    if let Ok(out) = output {
+        if out.status.success() {
+            let msg = String::from_utf8_lossy(&out.stdout).trim().to_string();
+            if !msg.is_empty() {
+                return format!("Recent work: {msg}");
+            }
+        }
+    }
+
+    "Unknown — no session transcript or git history found".into()
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.len() <= max {
+        s.to_string()
+    } else {
+        format!("{}...", &s[..max])
+    }
+}
+
+fn default_session_info() -> SessionInfo {
+    SessionInfo {
+        current_task: "Could not read session transcript".into(),
+        decisions: Vec::new(),
+        last_error: None,
+        last_output: None,
+    }
+}

package/core/src/capture/todos.rs

@@ -0,0 +1,104 @@
+//! Read TodoWrite state from Claude Code session.
+
+use crate::TodoItem;
+use std::path::Path;
+
+/// Attempt to read the current todo list from the latest session transcript.
+pub fn read_todos(project_dir: &Path) -> Vec<TodoItem> {
+    // Try to read from the latest session's JSONL
+    let _session = super::session::read_latest_session(project_dir);
+
+    // Parse from the session info — todos are embedded in tool_use calls
+    // For now, try to read from the last TodoWrite call in the transcript
+    let transcript_todos = read_todos_from_transcript(project_dir);
+    if !transcript_todos.is_empty() {
+        return transcript_todos;
+    }
+
+    // Fallback: try to infer from git
+    Vec::new()
+}
+
+fn read_todos_from_transcript(project_dir: &Path) -> Vec<TodoItem> {
+    let home = std::env::var("HOME").unwrap_or_default();
+    let claude_projects = std::path::PathBuf::from(&home).join(".claude/projects");
+    if !claude_projects.exists() {
+        return Vec::new();
+    }
+
+    let proj_str = project_dir.to_string_lossy().replace('/', "-");
+    let dir = claude_projects.join(&proj_str);
+    if !dir.exists() {
+        // Try suffix match
+        let entries = std::fs::read_dir(&claude_projects).ok();
+        let dir_name = project_dir.file_name().map(|n| n.to_string_lossy().to_string());
+        let matched_dir = entries.and_then(|es| {
+            let name = dir_name?;
+            for e in es.flatten() {
+                let n = e.file_name().to_string_lossy().to_string();
+                if n.ends_with(&name) && e.path().is_dir() {
+                    return Some(e.path());
+                }
+            }
+            None
+        });
+        if matched_dir.is_none() {
+            return Vec::new();
+        }
+        return parse_todos_from_dir(&matched_dir.unwrap());
+    }
+
+    parse_todos_from_dir(&dir)
+}
+
+fn parse_todos_from_dir(dir: &Path) -> Vec<TodoItem> {
+    // Find latest JSONL
+    let mut newest: Option<(std::path::PathBuf, std::time::SystemTime)> = None;
+    if let Ok(entries) = std::fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().map(|e| e == "jsonl").unwrap_or(false) {
+                if let Ok(meta) = path.metadata() {
+                    if let Ok(modified) = meta.modified() {
+                        if newest.as_ref().map_or(true, |(_, t)| modified > *t) {
+                            newest = Some((path, modified));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let Some((path, _)) = newest else { return Vec::new() };
+    let content = std::fs::read_to_string(&path).unwrap_or_default();
+
+    // Scan for the last TodoWrite tool_use call
+    let mut last_todos: Vec<TodoItem> = Vec::new();
+    for line in content.lines().rev() {
+        let Ok(val) = serde_json::from_str::<serde_json::Value>(line) else { continue };
+
+        // Look for tool_use with name "TodoWrite"
+        if let Some(content) = val.get("message").and_then(|m| m.get("content")).and_then(|c| c.as_array()) {
+            for item in content {
+                if item.get("type").and_then(|t| t.as_str()) == Some("tool_use") {
+                    if item.get("name").and_then(|n| n.as_str()) == Some("TodoWrite") {
+                        if let Some(input) = item.get("input") {
+                            if let Some(todos) = input.get("todos").and_then(|t| t.as_array()) {
+                                last_todos = todos.iter().filter_map(|t| {
+                                    let content = t.get("content")?.as_str()?.to_string();
+                                    let status = t.get("status")?.as_str()?.to_string();
+                                    Some(TodoItem { content, status })
+                                }).collect();
+                                if !last_todos.is_empty() {
+                                    return last_todos;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    last_todos
+}

package/core/src/detect/mod.rs

@@ -0,0 +1,80 @@
+//! Rate limit detection — identifies when Claude Code has hit its limit.
+
+use anyhow::Result;
+
+/// Signals from tool output that suggest a rate limit.
+static RATE_LIMIT_SIGNALS: &[&str] = &[
+    "rate limit",
+    "rate_limit",
+    "quota exceeded",
+    "too many requests",
+    "429",
+    "capacity",
+    "overloaded",
+    "try again later",
+    "usage limit",
+    "limit reached",
+    "context window full",
+    "maximum context",
+];
+
+/// Check if a tool output string contains rate limit signals.
+pub fn is_rate_limited(text: &str) -> bool {
+    let lower = text.to_lowercase();
+    RATE_LIMIT_SIGNALS.iter().any(|sig| lower.contains(sig))
+}
+
+/// Hook handler — reads PostToolUse JSON, checks for rate limit,
+/// triggers handoff if detected.
+pub fn check_hook_output(raw: &str) -> Option<RateLimitDetection> {
+    let val: serde_json::Value = serde_json::from_str(raw).ok()?;
+
+    let tool_output = val.get("tool_output").and_then(|v| v.as_str()).unwrap_or("");
+    let tool_name = val.get("tool_name").and_then(|v| v.as_str()).unwrap_or("");
+
+    if is_rate_limited(tool_output) {
+        return Some(RateLimitDetection {
+            tool_name: tool_name.to_string(),
+            signal: extract_signal(tool_output),
+            full_output: tool_output.to_string(),
+        });
+    }
+
+    None
+}
+
+/// Watch the Claude Code process for exit with rate limit.
+pub fn watch_claude_process() -> Result<WatchResult> {
+    // Check if Claude Code is running
+    let output = std::process::Command::new("pgrep")
+        .args(["-f", "claude"])
+        .output()?;
+
+    let running = output.status.success();
+
+    Ok(WatchResult {
+        claude_running: running,
+        rate_limited: false, // Can't detect from outside without hook
+    })
+}
+
+pub struct RateLimitDetection {
+    pub tool_name: String,
+    pub signal: String,
+    pub full_output: String,
+}
+
+pub struct WatchResult {
+    pub claude_running: bool,
+    pub rate_limited: bool,
+}
+
+fn extract_signal(text: &str) -> String {
+    let lower = text.to_lowercase();
+    for sig in RATE_LIMIT_SIGNALS {
+        if lower.contains(sig) {
+            return sig.to_string();
+        }
+    }
+    "unknown".into()
+}