@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/discover/provider.rs

@@ -0,0 +1,388 @@
+use anyhow::{Context, Result};
+use std::collections::HashMap;
+use std::fs;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::time::{Duration, SystemTime};
+use walkdir::WalkDir;
+
+/// A command extracted from a session file.
+#[derive(Debug)]
+pub struct ExtractedCommand {
+    pub command: String,
+    pub output_len: Option<usize>,
+    #[allow(dead_code)]
+    pub session_id: String,
+    /// Actual output content (first ~1000 chars for error detection)
+    pub output_content: Option<String>,
+    /// Whether the tool_result indicated an error
+    pub is_error: bool,
+    /// Chronological sequence index within the session
+    pub sequence_index: usize,
+}
+
+/// Trait for session providers (Claude Code, future: Cursor, Windsurf).
+pub trait SessionProvider {
+    fn discover_sessions(
+        &self,
+        project_filter: Option<&str>,
+        since_days: Option<u64>,
+    ) -> Result<Vec<PathBuf>>;
+    fn extract_commands(&self, path: &Path) -> Result<Vec<ExtractedCommand>>;
+}
+
+pub struct ClaudeProvider;
+
+impl ClaudeProvider {
+    /// Get the base directory for Claude Code projects.
+    fn projects_dir() -> Result<PathBuf> {
+        let home = dirs::home_dir().context("could not determine home directory")?;
+        let dir = home.join(".claude").join("projects");
+        if !dir.exists() {
+            anyhow::bail!(
+                "Claude Code projects directory not found: {}\nMake sure Claude Code has been used at least once.",
+                dir.display()
+            );
+        }
+        Ok(dir)
+    }
+
+    /// Encode a filesystem path to Claude Code's directory name format.
+    /// `/Users/foo/bar` → `-Users-foo-bar`
+    pub fn encode_project_path(path: &str) -> String {
+        path.replace('/', "-")
+    }
+}
+
+impl SessionProvider for ClaudeProvider {
+    fn discover_sessions(
+        &self,
+        project_filter: Option<&str>,
+        since_days: Option<u64>,
+    ) -> Result<Vec<PathBuf>> {
+        let projects_dir = Self::projects_dir()?;
+        let cutoff = since_days.map(|days| {
+            SystemTime::now()
+                .checked_sub(Duration::from_secs(days * 86400))
+                .unwrap_or(SystemTime::UNIX_EPOCH)
+        });
+
+        let mut sessions = Vec::new();
+
+        // List project directories
+        let entries = fs::read_dir(&projects_dir)
+            .with_context(|| format!("failed to read {}", projects_dir.display()))?;
+
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if !path.is_dir() {
+                continue;
+            }
+
+            // Apply project filter: substring match on directory name
+            if let Some(filter) = project_filter {
+                let dir_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+                if !dir_name.contains(filter) {
+                    continue;
+                }
+            }
+
+            // Walk the project directory recursively (catches subagents/)
+            for walk_entry in WalkDir::new(&path)
+                .follow_links(false)
+                .into_iter()
+                .filter_map(|e| e.ok())
+            {
+                let file_path = walk_entry.path();
+                if file_path.extension().and_then(|e| e.to_str()) != Some("jsonl") {
+                    continue;
+                }
+
+                // Apply mtime filter
+                if let Some(cutoff_time) = cutoff {
+                    if let Ok(meta) = fs::metadata(file_path) {
+                        if let Ok(mtime) = meta.modified() {
+                            if mtime < cutoff_time {
+                                continue;
+                            }
+                        }
+                    }
+                }
+
+                sessions.push(file_path.to_path_buf());
+            }
+        }
+
+        Ok(sessions)
+    }
+
+    fn extract_commands(&self, path: &Path) -> Result<Vec<ExtractedCommand>> {
+        let file =
+            fs::File::open(path).with_context(|| format!("failed to open {}", path.display()))?;
+        let reader = BufReader::new(file);
+
+        let session_id = path
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .unwrap_or("unknown")
+            .to_string();
+
+        // First pass: collect all tool_use Bash commands with their IDs and sequence
+        // Second pass (same loop): collect tool_result output lengths, content, and error status
+        let mut pending_tool_uses: Vec<(String, String, usize)> = Vec::new(); // (tool_use_id, command, sequence)
+        let mut tool_results: HashMap<String, (usize, String, bool)> = HashMap::new(); // (len, content, is_error)
+        let mut commands = Vec::new();
+        let mut sequence_counter = 0;
+
+        for line in reader.lines() {
+            let line = match line {
+                Ok(l) => l,
+                Err(_) => continue,
+            };
+
+            // Pre-filter: skip lines that can't contain Bash tool_use or tool_result
+            if !line.contains("\"Bash\"") && !line.contains("\"tool_result\"") {
+                continue;
+            }
+
+            let entry: serde_json::Value = match serde_json::from_str(&line) {
+                Ok(v) => v,
+                Err(_) => continue,
+            };
+
+            let entry_type = entry.get("type").and_then(|t| t.as_str()).unwrap_or("");
+
+            match entry_type {
+                "assistant" => {
+                    // Look for tool_use Bash blocks in message.content
+                    if let Some(content) =
+                        entry.pointer("/message/content").and_then(|c| c.as_array())
+                    {
+                        for block in content {
+                            if block.get("type").and_then(|t| t.as_str()) == Some("tool_use")
+                                && block.get("name").and_then(|n| n.as_str()) == Some("Bash")
+                            {
+                                if let (Some(id), Some(cmd)) = (
+                                    block.get("id").and_then(|i| i.as_str()),
+                                    block.pointer("/input/command").and_then(|c| c.as_str()),
+                                ) {
+                                    pending_tool_uses.push((
+                                        id.to_string(),
+                                        cmd.to_string(),
+                                        sequence_counter,
+                                    ));
+                                    sequence_counter += 1;
+                                }
+                            }
+                        }
+                    }
+                }
+                "user" => {
+                    // Look for tool_result blocks
+                    if let Some(content) =
+                        entry.pointer("/message/content").and_then(|c| c.as_array())
+                    {
+                        for block in content {
+                            if block.get("type").and_then(|t| t.as_str()) == Some("tool_result") {
+                                if let Some(id) = block.get("tool_use_id").and_then(|i| i.as_str())
+                                {
+                                    // Get content, length, and error status
+                                    let content =
+                                        block.get("content").and_then(|c| c.as_str()).unwrap_or("");
+
+                                    let output_len = content.len();
+                                    let is_error = block
+                                        .get("is_error")
+                                        .and_then(|e| e.as_bool())
+                                        .unwrap_or(false);
+
+                                    // Store first ~1000 chars of content for error detection
+                                    let content_preview: String =
+                                        content.chars().take(1000).collect();
+
+                                    tool_results.insert(
+                                        id.to_string(),
+                                        (output_len, content_preview, is_error),
+                                    );
+                                }
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Match tool_uses with their results
+        for (tool_id, command, sequence_index) in pending_tool_uses {
+            let (output_len, output_content, is_error) = tool_results
+                .get(&tool_id)
+                .map(|(len, content, err)| (Some(*len), Some(content.clone()), *err))
+                .unwrap_or((None, None, false));
+
+            commands.push(ExtractedCommand {
+                command,
+                output_len,
+                session_id: session_id.clone(),
+                output_content,
+                is_error,
+                sequence_index,
+            });
+        }
+
+        Ok(commands)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+
+    fn make_jsonl(lines: &[&str]) -> tempfile::NamedTempFile {
+        let mut f = tempfile::NamedTempFile::new().unwrap();
+        for line in lines {
+            writeln!(f, "{}", line).unwrap();
+        }
+        f.flush().unwrap();
+        f
+    }
+
+    #[test]
+    fn test_extract_assistant_bash() {
+        let jsonl = make_jsonl(&[
+            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_abc","name":"Bash","input":{"command":"git status"}}]}}"#,
+            r#"{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_abc","content":"On branch master\nnothing to commit"}]}}"#,
+        ]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(cmds[0].command, "git status");
+        assert!(cmds[0].output_len.is_some());
+        assert_eq!(
+            cmds[0].output_len.unwrap(),
+            "On branch master\nnothing to commit".len()
+        );
+    }
+
+    #[test]
+    fn test_extract_non_bash_ignored() {
+        let jsonl = make_jsonl(&[
+            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_abc","name":"Read","input":{"file_path":"/tmp/foo"}}]}}"#,
+        ]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 0);
+    }
+
+    #[test]
+    fn test_extract_non_message_ignored() {
+        let jsonl =
+            make_jsonl(&[r#"{"type":"file-history-snapshot","messageId":"abc","snapshot":{}}"#]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 0);
+    }
+
+    #[test]
+    fn test_extract_multiple_tools() {
+        let jsonl = make_jsonl(&[
+            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_1","name":"Bash","input":{"command":"git status"}},{"type":"tool_use","id":"toolu_2","name":"Bash","input":{"command":"git diff"}}]}}"#,
+        ]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 2);
+        assert_eq!(cmds[0].command, "git status");
+        assert_eq!(cmds[1].command, "git diff");
+    }
+
+    #[test]
+    fn test_extract_malformed_line() {
+        let jsonl = make_jsonl(&[
+            "this is not json at all",
+            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_ok","name":"Bash","input":{"command":"ls"}}]}}"#,
+        ]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(cmds[0].command, "ls");
+    }
+
+    #[test]
+    fn test_encode_project_path() {
+        assert_eq!(
+            ClaudeProvider::encode_project_path("/Users/foo/bar"),
+            "-Users-foo-bar"
+        );
+    }
+
+    #[test]
+    fn test_encode_project_path_trailing_slash() {
+        assert_eq!(
+            ClaudeProvider::encode_project_path("/Users/foo/bar/"),
+            "-Users-foo-bar-"
+        );
+    }
+
+    #[test]
+    fn test_match_project_filter() {
+        let encoded = ClaudeProvider::encode_project_path("/Users/foo/Sites/rtk");
+        assert!(encoded.contains("rtk"));
+        assert!(encoded.contains("Sites"));
+    }
+
+    #[test]
+    fn test_extract_output_content() {
+        let jsonl = make_jsonl(&[
+            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_abc","name":"Bash","input":{"command":"git commit --ammend"}}]}}"#,
+            r#"{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_abc","content":"error: unexpected argument '--ammend'","is_error":true}]}}"#,
+        ]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(cmds[0].command, "git commit --ammend");
+        assert_eq!(cmds[0].is_error, true);
+        assert!(cmds[0].output_content.is_some());
+        assert_eq!(
+            cmds[0].output_content.as_ref().unwrap(),
+            "error: unexpected argument '--ammend'"
+        );
+    }
+
+    #[test]
+    fn test_extract_is_error_flag() {
+        let jsonl = make_jsonl(&[
+            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_1","name":"Bash","input":{"command":"ls"}},{"type":"tool_use","id":"toolu_2","name":"Bash","input":{"command":"invalid_cmd"}}]}}"#,
+            r#"{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_1","content":"file1.txt","is_error":false},{"type":"tool_result","tool_use_id":"toolu_2","content":"command not found","is_error":true}]}}"#,
+        ]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 2);
+        assert_eq!(cmds[0].is_error, false);
+        assert_eq!(cmds[1].is_error, true);
+    }
+
+    #[test]
+    fn test_extract_sequence_ordering() {
+        let jsonl = make_jsonl(&[
+            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_1","name":"Bash","input":{"command":"first"}},{"type":"tool_use","id":"toolu_2","name":"Bash","input":{"command":"second"}},{"type":"tool_use","id":"toolu_3","name":"Bash","input":{"command":"third"}}]}}"#,
+        ]);
+
+        let provider = ClaudeProvider;
+        let cmds = provider.extract_commands(jsonl.path()).unwrap();
+        assert_eq!(cmds.len(), 3);
+        assert_eq!(cmds[0].sequence_index, 0);
+        assert_eq!(cmds[1].sequence_index, 1);
+        assert_eq!(cmds[2].sequence_index, 2);
+        assert_eq!(cmds[0].command, "first");
+        assert_eq!(cmds[1].command, "second");
+        assert_eq!(cmds[2].command, "third");
+    }
+}