@masyv/relay 0.4.0 → 1.0.0

package/core/src/resume.rs

@@ -0,0 +1,202 @@
+//! `relay resume` — When Claude comes back, show what happened during the handoff.
+//! Reads the latest handoff file + git diff since handoff time → generates a
+//! "welcome back" prompt so Claude (or any agent) can pick up with full awareness
+//! of what the fallback agent did.
+
+use anyhow::{Context, Result};
+use std::path::Path;
+
+#[derive(Debug, serde::Serialize)]
+pub struct ResumeReport {
+    pub handoff_file: String,
+    pub handoff_time: String,
+    pub original_task: String,
+    pub changes_since: Vec<String>,
+    pub new_commits: Vec<String>,
+    pub diff_stat: String,
+    pub resume_prompt: String,
+}
+
+/// Build a resume report from the latest handoff.
+pub fn build_resume(project_dir: &Path) -> Result<ResumeReport> {
+    let relay_dir = project_dir.join(".relay");
+    if !relay_dir.exists() {
+        anyhow::bail!("No .relay/ directory found. Run 'relay handoff' first.");
+    }
+
+    // Find latest handoff file
+    let handoff_file = find_latest_handoff(&relay_dir)?;
+    let handoff_content = std::fs::read_to_string(&handoff_file)
+        .context("Failed to read handoff file")?;
+
+    // Extract timestamp from filename: handoff_20260405_141328.md
+    let filename = handoff_file
+        .file_name()
+        .unwrap_or_default()
+        .to_string_lossy();
+    let handoff_time = parse_handoff_timestamp(&filename);
+
+    // Extract original task from handoff content
+    let original_task = extract_section(&handoff_content, "## CURRENT TASK")
+        .unwrap_or_else(|| "Unknown".into());
+
+    // Git changes since handoff
+    let changes_since = git_changed_files(project_dir, &handoff_time);
+    let new_commits = git_commits_since(project_dir, &handoff_time);
+    let diff_stat = git_diff_stat(project_dir, &handoff_time);
+
+    // Build resume prompt
+    let resume_prompt = build_resume_prompt(
+        &original_task,
+        &changes_since,
+        &new_commits,
+        &diff_stat,
+        &handoff_time,
+    );
+
+    Ok(ResumeReport {
+        handoff_file: handoff_file.to_string_lossy().to_string(),
+        handoff_time,
+        original_task,
+        changes_since,
+        new_commits,
+        diff_stat,
+        resume_prompt,
+    })
+}
+
+fn find_latest_handoff(relay_dir: &Path) -> Result<std::path::PathBuf> {
+    let mut latest: Option<(std::path::PathBuf, std::time::SystemTime)> = None;
+    for entry in std::fs::read_dir(relay_dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let name = path.file_name().unwrap_or_default().to_string_lossy();
+        if name.starts_with("handoff_") && name.ends_with(".md") {
+            if let Ok(meta) = path.metadata() {
+                if let Ok(modified) = meta.modified() {
+                    if latest.as_ref().map_or(true, |(_, t)| modified > *t) {
+                        latest = Some((path, modified));
+                    }
+                }
+            }
+        }
+    }
+    latest
+        .map(|(p, _)| p)
+        .ok_or_else(|| anyhow::anyhow!("No handoff files found in .relay/"))
+}
+
+fn parse_handoff_timestamp(filename: &str) -> String {
+    // handoff_20260405_141328.md → 2026-04-05 14:13:28
+    let ts = filename
+        .strip_prefix("handoff_")
+        .unwrap_or("")
+        .strip_suffix(".md")
+        .unwrap_or("");
+    if ts.len() >= 15 {
+        format!(
+            "{}-{}-{} {}:{}:{}",
+            &ts[0..4], &ts[4..6], &ts[6..8],
+            &ts[9..11], &ts[11..13], &ts[13..15]
+        )
+    } else {
+        "unknown".into()
+    }
+}
+
+fn extract_section(content: &str, header: &str) -> Option<String> {
+    let start = content.find(header)?;
+    let after = &content[start + header.len()..];
+    let end = after.find("\n## ").unwrap_or(after.len());
+    let section = after[..end].trim();
+    if section.is_empty() { None } else { Some(section.to_string()) }
+}
+
+fn git_changed_files(dir: &Path, _since: &str) -> Vec<String> {
+    let output = std::process::Command::new("git")
+        .current_dir(dir)
+        .args(["diff", "--name-only", "HEAD"])
+        .output()
+        .ok();
+    output
+        .filter(|o| o.status.success())
+        .map(|o| {
+            String::from_utf8_lossy(&o.stdout)
+                .lines()
+                .filter(|l| !l.is_empty())
+                .map(String::from)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn git_commits_since(dir: &Path, since: &str) -> Vec<String> {
+    let output = std::process::Command::new("git")
+        .current_dir(dir)
+        .args(["log", "--oneline", "-10", "--since", since])
+        .output()
+        .ok();
+    output
+        .filter(|o| o.status.success())
+        .map(|o| {
+            String::from_utf8_lossy(&o.stdout)
+                .lines()
+                .filter(|l| !l.is_empty())
+                .map(String::from)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn git_diff_stat(dir: &Path, _since: &str) -> String {
+    let output = std::process::Command::new("git")
+        .current_dir(dir)
+        .args(["diff", "--stat", "HEAD"])
+        .output()
+        .ok();
+    output
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .unwrap_or_default()
+}
+
+fn build_resume_prompt(
+    task: &str,
+    changed: &[String],
+    commits: &[String],
+    diff_stat: &str,
+    handoff_time: &str,
+) -> String {
+    let mut prompt = format!(
+        "══ RELAY RESUME ══════════════════════════════\n\
+        You are resuming a session that was handed off at {handoff_time}.\n\
+        A fallback agent continued the work. Here's what happened:\n\
+        ══════════════════════════════════════════════\n\n\
+        ## ORIGINAL TASK\n\n{task}\n"
+    );
+
+    if !commits.is_empty() {
+        prompt.push_str("\n## COMMITS MADE DURING HANDOFF\n\n");
+        for c in commits {
+            prompt.push_str(&format!("  {c}\n"));
+        }
+    }
+
+    if !changed.is_empty() {
+        prompt.push_str(&format!("\n## FILES CHANGED ({})\n\n", changed.len()));
+        for f in changed.iter().take(20) {
+            prompt.push_str(&format!("  {f}\n"));
+        }
+    }
+
+    if !diff_stat.is_empty() {
+        prompt.push_str(&format!("\n## DIFF SUMMARY\n\n{diff_stat}\n"));
+    }
+
+    prompt.push_str("\n## INSTRUCTIONS\n\n\
+        Review what the fallback agent did above.\n\
+        Continue from the current state. Check if the original task is complete.\n\
+        If not, finish it.\n");
+
+    prompt
+}

package/core/src/tui.rs

@@ -0,0 +1,324 @@
+//! Beautiful terminal UI for Relay — spinners, boxes, interactive prompts.
+
+use colored::Colorize;
+use console::Term;
+use indicatif::{ProgressBar, ProgressStyle};
+use std::time::Duration;
+
+// ─── Banner ─────────────────────────────────────────────────────────────────
+
+pub fn print_banner() {
+    let banner = r#"
+  ╔═══════════════════════════════════════════════╗
+  ║                                               ║
+  ║   ⚡ R E L A Y                                ║
+  ║   Cross-agent context handoff                 ║
+  ║                                               ║
+  ╚═══════════════════════════════════════════════╝
+"#;
+    eprintln!("{}", banner.cyan());
+}
+
+// ─── Spinners ───────────────────────────────────────────────────────────────
+
+pub fn spinner(msg: &str) -> ProgressBar {
+    let pb = ProgressBar::new_spinner();
+    pb.set_style(
+        ProgressStyle::with_template("  {spinner:.cyan} {msg}")
+            .unwrap()
+            .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏", "✓"]),
+    );
+    pb.set_message(msg.to_string());
+    pb.enable_steady_tick(Duration::from_millis(80));
+    pb
+}
+
+pub fn step(num: usize, total: usize, msg: &str) -> ProgressBar {
+    let pb = ProgressBar::new_spinner();
+    pb.set_style(
+        ProgressStyle::with_template(&format!(
+            "  {{spinner:.cyan}} [{}/{}] {{msg}}",
+            num, total
+        ))
+        .unwrap()
+        .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏", "✓"]),
+    );
+    pb.set_message(msg.to_string());
+    pb.enable_steady_tick(Duration::from_millis(80));
+    pb
+}
+
+// ─── Boxes ──────────────────────────────────────────────────────────────────
+
+pub fn print_box(title: &str, content: &str) {
+    let term_width = Term::stdout().size().1 as usize;
+    let width = term_width.min(72).max(40);
+    let inner = width - 4;
+
+    // Top border
+    eprintln!("  ╭{}╮", "─".repeat(inner + 2));
+
+    // Title
+    let title_padded = format!(" {} ", title);
+    let pad = inner.saturating_sub(title_padded.len()) + 1;
+    eprintln!("  │{}{}│", title_padded.bold().cyan(), " ".repeat(pad));
+
+    // Separator
+    eprintln!("  ├{}┤", "─".repeat(inner + 2));
+
+    // Content lines
+    for line in content.lines() {
+        let display_line = if line.len() > inner {
+            let mut end = inner.saturating_sub(1);
+            while end > 0 && !line.is_char_boundary(end) { end -= 1; }
+            format!("{}…", &line[..end])
+        } else {
+            line.to_string()
+        };
+        let pad = inner.saturating_sub(display_line.len()) + 1;
+        eprintln!("  │ {}{} │", display_line, " ".repeat(pad.saturating_sub(1)));
+    }
+
+    // Bottom border
+    eprintln!("  ╰{}╯", "─".repeat(inner + 2));
+}
+
+pub fn print_section(icon: &str, title: &str) {
+    eprintln!();
+    eprintln!("  {} {}", icon, title.bold());
+    eprintln!("  {}", "─".repeat(50).dimmed());
+}
+
+// ─── Agent Select ───────────────────────────────────────────────────────────
+
+pub fn select_agent(agents: &[(String, bool, String)]) -> Option<String> {
+    let items: Vec<String> = agents
+        .iter()
+        .map(|(name, available, reason)| {
+            if *available {
+                format!("✅  {} — {}", name, reason)
+            } else {
+                format!("❌  {} — {}", name, reason)
+            }
+        })
+        .collect();
+
+    eprintln!();
+    let selection = dialoguer::FuzzySelect::with_theme(
+        &dialoguer::theme::ColorfulTheme::default(),
+    )
+    .with_prompt("  Select target agent")
+    .items(&items)
+    .default(0)
+    .interact_opt()
+    .ok()
+    .flatten()?;
+
+    let (name, available, _) = &agents[selection];
+    if !*available {
+        eprintln!(
+            "\n  {} {} is not available.",
+            "⚠️ ".yellow(),
+            name.bold()
+        );
+        return None;
+    }
+
+    Some(name.clone())
+}
+
+// ─── Status Display ─────────────────────────────────────────────────────────
+
+pub fn print_snapshot(snapshot: &crate::SessionSnapshot) {
+    eprintln!();
+    let term_width = Term::stdout().size().1 as usize;
+    let width = term_width.min(72).max(40);
+    eprintln!("  {}", "═".repeat(width).cyan());
+    eprintln!(
+        "  {}  {}",
+        "📋".to_string(),
+        "Session Snapshot".bold().cyan()
+    );
+    eprintln!("  {}", "═".repeat(width).cyan());
+
+    // Project + time
+    eprintln!();
+    eprintln!("  {}  {}", "📁", snapshot.project_dir.dimmed());
+    eprintln!("  {}  {}", "🕐", snapshot.timestamp.dimmed());
+
+    // Current task
+    print_section("🎯", "Current Task");
+    eprintln!("  {}", snapshot.current_task);
+
+    // Todos
+    if !snapshot.todos.is_empty() {
+        print_section("📝", "Progress");
+        for t in &snapshot.todos {
+            let (icon, style) = match t.status.as_str() {
+                "completed" => ("✅", t.content.dimmed().to_string()),
+                "in_progress" => ("🔄", t.content.yellow().bold().to_string()),
+                _ => ("⏳", t.content.normal().to_string()),
+            };
+            eprintln!("  {icon}  {style}");
+        }
+    }
+
+    // Last error
+    if let Some(ref err) = snapshot.last_error {
+        print_section("🚨", "Last Error");
+        for line in err.lines().take(5) {
+            eprintln!("  {}", line.red());
+        }
+    }
+
+    // Decisions
+    if !snapshot.decisions.is_empty() {
+        print_section("💡", "Key Decisions");
+        for d in &snapshot.decisions {
+            eprintln!("  • {}", d.dimmed());
+        }
+    }
+
+    // Git
+    if let Some(ref git) = snapshot.git_state {
+        print_section("🔀", "Git State");
+        eprintln!("  Branch: {}", git.branch.green());
+        eprintln!("  {}", git.status_summary);
+        if !git.recent_commits.is_empty() {
+            eprintln!();
+            for c in git.recent_commits.iter().take(3) {
+                eprintln!("  {}", c.dimmed());
+            }
+        }
+    }
+
+    // Changed files
+    if !snapshot.recent_files.is_empty() {
+        print_section("📄", &format!("Changed Files ({})", snapshot.recent_files.len()));
+        for f in snapshot.recent_files.iter().take(10) {
+            eprintln!("  {f}");
+        }
+    }
+
+    // Conversation
+    if !snapshot.conversation.is_empty() {
+        print_section(
+            "💬",
+            &format!("Conversation ({} turns)", snapshot.conversation.len()),
+        );
+        let start = snapshot.conversation.len().saturating_sub(10);
+        for turn in &snapshot.conversation[start..] {
+            let (prefix, _color) = match turn.role.as_str() {
+                "user" => ("👤 YOU ", turn.content.normal().to_string()),
+                "assistant" => ("🤖 AI  ", turn.content.cyan().to_string()),
+                "assistant_tool" => ("🔧 TOOL", turn.content.dimmed().to_string()),
+                "tool_result" => ("📤 OUT ", turn.content.dimmed().to_string()),
+                _ => ("   ", turn.content.normal().to_string()),
+            };
+            let short = if turn.content.len() > 90 {
+                let mut end = 85;
+                while end > 0 && !turn.content.is_char_boundary(end) { end -= 1; }
+                format!("{}…", &turn.content[..end])
+            } else {
+                turn.content.clone()
+            };
+            let styled = match turn.role.as_str() {
+                "user" => short.normal().to_string(),
+                "assistant" => short.cyan().to_string(),
+                "assistant_tool" => short.dimmed().to_string(),
+                "tool_result" => short.dimmed().to_string(),
+                _ => short,
+            };
+            eprintln!("  {} {}", prefix.dimmed(), styled);
+        }
+    }
+
+    eprintln!();
+    eprintln!("  {}", "═".repeat(width).cyan());
+}
+
+// ─── Agents Display ─────────────────────────────────────────────────────────
+
+pub fn print_agents(
+    priority: &[String],
+    statuses: &[crate::AgentStatus],
+) {
+    eprintln!();
+    let term_width = Term::stdout().size().1 as usize;
+    let width = term_width.min(72).max(40);
+    eprintln!("  {}", "═".repeat(width).cyan());
+    eprintln!("  {}  {}", "🤖", "Available Agents".bold().cyan());
+    eprintln!("  {}", "═".repeat(width).cyan());
+    eprintln!();
+    eprintln!(
+        "  Priority: {}",
+        priority
+            .iter()
+            .map(|s| s.as_str())
+            .collect::<Vec<_>>()
+            .join(" → ")
+            .dimmed()
+    );
+    eprintln!();
+
+    for s in statuses {
+        if s.available {
+            eprintln!(
+                "  {}  {:<12} {}",
+                "✅",
+                s.name.green().bold(),
+                s.reason.dimmed()
+            );
+            if let Some(ref v) = s.version {
+                eprintln!("  {}  {:<12} {}", " ", "", format!("v{v}").dimmed());
+            }
+        } else {
+            eprintln!(
+                "  {}  {:<12} {}",
+                "❌",
+                s.name.dimmed(),
+                s.reason.dimmed()
+            );
+        }
+    }
+
+    let available = statuses.iter().filter(|s| s.available).count();
+    eprintln!();
+    if available == 0 {
+        eprintln!(
+            "  {} {}",
+            "⚠️ ",
+            "No agents available. Run 'relay init' to configure.".yellow()
+        );
+    } else {
+        eprintln!(
+            "  {} {} agent{} ready for handoff",
+            "🚀",
+            available.to_string().green().bold(),
+            if available == 1 { "" } else { "s" }
+        );
+    }
+    eprintln!();
+}
+
+// ─── Handoff Result ─────────────────────────────────────────────────────────
+
+pub fn print_handoff_success(agent: &str, file: &str) {
+    eprintln!();
+    eprintln!(
+        "  {} {}",
+        "✅",
+        format!("Handed off to {agent}").green().bold()
+    );
+    eprintln!("  📄 {}", file.dimmed());
+    eprintln!();
+}
+
+pub fn print_handoff_fail(message: &str, file: &str) {
+    eprintln!();
+    eprintln!("  {} {}", "❌", message.red());
+    eprintln!();
+    eprintln!("  💡 Context saved — copy-paste into any AI:");
+    eprintln!("     {}", file.cyan());
+    eprintln!();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masyv/relay",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "Relay — When Claude's rate limit hits, another agent picks up exactly where you left off. Captures session state and hands off to Codex, Gemini, Ollama, or GPT-4.",
   "scripts": {
     "build": "./scripts/build.sh",