@hasna/terminal 2.3.0 → 2.3.2

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

@@ -1,388 +0,0 @@
-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");
-    }
-}