@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/learn/mod.rs

@@ -0,0 +1,119 @@
+pub mod detector;
+pub mod report;
+
+use crate::discover::provider::{ClaudeProvider, SessionProvider};
+use anyhow::Result;
+use detector::{deduplicate_corrections, find_corrections, CommandExecution};
+use report::{format_console_report, write_rules_file};
+
+pub fn run(
+    project: Option<String>,
+    all: bool,
+    since: u64,
+    format: String,
+    write_rules: bool,
+    min_confidence: f64,
+    min_occurrences: usize,
+) -> Result<()> {
+    let provider = ClaudeProvider;
+
+    // Determine project filter (same logic as discover)
+    let project_filter = if all {
+        None
+    } else if let Some(p) = project {
+        Some(p)
+    } else {
+        // Default: current working directory
+        let cwd = std::env::current_dir()?;
+        let cwd_str = cwd.to_string_lossy().to_string();
+        let encoded = ClaudeProvider::encode_project_path(&cwd_str);
+        Some(encoded)
+    };
+
+    // Discover sessions
+    let sessions = provider.discover_sessions(project_filter.as_deref(), Some(since))?;
+
+    if sessions.is_empty() {
+        println!("No Claude Code sessions found in the last {} days.", since);
+        return Ok(());
+    }
+
+    // Extract commands from all sessions
+    let mut all_commands: Vec<CommandExecution> = Vec::new();
+
+    for session_path in &sessions {
+        let extracted = match provider.extract_commands(session_path) {
+            Ok(cmds) => cmds,
+            Err(_) => continue, // Skip malformed sessions
+        };
+
+        for ext_cmd in extracted {
+            // Only process commands with output content
+            if let Some(output) = ext_cmd.output_content {
+                all_commands.push(CommandExecution {
+                    command: ext_cmd.command,
+                    is_error: ext_cmd.is_error,
+                    output,
+                });
+            }
+        }
+    }
+
+    // Sort by sequence index to maintain chronological order
+    // (already sorted by extraction order within each session)
+
+    // Find corrections
+    let corrections = find_corrections(&all_commands);
+
+    if corrections.is_empty() {
+        println!(
+            "No CLI corrections detected in {} sessions.",
+            sessions.len()
+        );
+        return Ok(());
+    }
+
+    // Filter by confidence
+    let filtered: Vec<_> = corrections
+        .into_iter()
+        .filter(|c| c.confidence >= min_confidence)
+        .collect();
+
+    // Deduplicate
+    let mut rules = deduplicate_corrections(filtered.clone());
+
+    // Filter by occurrences
+    rules.retain(|r| r.occurrences >= min_occurrences);
+
+    // Output
+    match format.as_str() {
+        "json" => {
+            // JSON output
+            let json = serde_json::json!({
+                "sessions_scanned": sessions.len(),
+                "total_corrections": filtered.len(),
+                "rules": rules.iter().map(|r| serde_json::json!({
+                    "wrong": r.wrong_pattern,
+                    "right": r.right_pattern,
+                    "error_type": r.error_type.as_str(),
+                    "occurrences": r.occurrences,
+                    "base_command": r.base_command,
+                })).collect::<Vec<_>>(),
+            });
+            println!("{}", serde_json::to_string_pretty(&json)?);
+        }
+        _ => {
+            // Text output
+            let report = format_console_report(&rules, filtered.len(), sessions.len(), since);
+            print!("{}", report);
+
+            if write_rules && !rules.is_empty() {
+                let rules_path = ".claude/rules/cli-corrections.md";
+                write_rules_file(&rules, rules_path)?;
+                println!("\nWritten to: {}", rules_path);
+            }
+        }
+    }
+
+    Ok(())
+}

package/temp/rtk/src/learn/report.rs

@@ -0,0 +1,184 @@
+use crate::learn::detector::CorrectionRule;
+use anyhow::Result;
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+
+pub fn format_console_report(
+    rules: &[CorrectionRule],
+    total_corrections: usize,
+    sessions: usize,
+    days: u64,
+) -> String {
+    let mut output = String::new();
+
+    output.push_str(&format!(
+        "RTK Learn -- {} rules from {} corrections ({} sessions, {} days)\n",
+        rules.len(),
+        total_corrections,
+        sessions,
+        days
+    ));
+
+    if rules.is_empty() {
+        output.push_str("\nNo CLI corrections detected.\n");
+        return output;
+    }
+
+    output.push('\n');
+
+    for rule in rules {
+        let count_marker = if rule.occurrences > 1 {
+            format!("[{}x] ", rule.occurrences)
+        } else {
+            "     ".to_string()
+        };
+
+        output.push_str(&format!(
+            "{}{}  →  {}\n",
+            count_marker, rule.wrong_pattern, rule.right_pattern
+        ));
+
+        // Show error snippet (first line only)
+        let error_line = rule.example_error.lines().next().unwrap_or("").trim();
+        if !error_line.is_empty() {
+            output.push_str(&format!("     Error: {}\n", error_line));
+        }
+    }
+
+    output
+}
+
+pub fn write_rules_file(rules: &[CorrectionRule], path: &str) -> Result<()> {
+    let path_obj = Path::new(path);
+
+    // Create parent directory if it doesn't exist
+    if let Some(parent) = path_obj.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    let mut content = String::new();
+    content.push_str("# CLI Corrections (auto-generated by rtk learn)\n");
+    content.push_str("# Run `rtk learn --write-rules` to update\n\n");
+
+    if rules.is_empty() {
+        content.push_str("No CLI corrections detected yet.\n");
+        fs::write(path, content)?;
+        return Ok(());
+    }
+
+    // Group by base command
+    let mut grouped: HashMap<String, Vec<&CorrectionRule>> = HashMap::new();
+    for rule in rules {
+        grouped
+            .entry(rule.base_command.clone())
+            .or_default()
+            .push(rule);
+    }
+
+    // Sort base commands alphabetically
+    let mut base_commands: Vec<String> = grouped.keys().cloned().collect();
+    base_commands.sort();
+
+    for base_cmd in base_commands {
+        let rules_for_cmd = grouped.get(&base_cmd).unwrap();
+
+        // Capitalize first letter for section header
+        let section_header = capitalize_first(&base_cmd);
+        content.push_str(&format!("## {}\n", section_header));
+
+        for rule in rules_for_cmd {
+            let occurrence_note = if rule.occurrences > 1 {
+                format!(" (seen {}x)", rule.occurrences)
+            } else {
+                String::new()
+            };
+
+            content.push_str(&format!(
+                "- Use `{}` not `{}`{}\n",
+                rule.right_pattern, rule.wrong_pattern, occurrence_note
+            ));
+        }
+
+        content.push('\n');
+    }
+
+    fs::write(path, content)?;
+    Ok(())
+}
+
+fn capitalize_first(s: &str) -> String {
+    let mut chars = s.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::learn::detector::ErrorType;
+
+    #[test]
+    fn test_format_console_report_empty() {
+        let report = format_console_report(&[], 0, 0, 30);
+        assert!(report.contains("0 rules"));
+        assert!(report.contains("0 corrections"));
+        assert!(report.contains("No CLI corrections detected"));
+    }
+
+    #[test]
+    fn test_format_console_report_with_rules() {
+        let rules = vec![
+            CorrectionRule {
+                wrong_pattern: "git commit --ammend".to_string(),
+                right_pattern: "git commit --amend".to_string(),
+                error_type: ErrorType::UnknownFlag,
+                occurrences: 3,
+                base_command: "git commit".to_string(),
+                example_error: "error: unexpected argument '--ammend'".to_string(),
+            },
+            CorrectionRule {
+                wrong_pattern: "gh pr edit -t".to_string(),
+                right_pattern: "gh pr edit --title".to_string(),
+                error_type: ErrorType::UnknownFlag,
+                occurrences: 1,
+                base_command: "gh pr".to_string(),
+                example_error: "unknown flag: -t".to_string(),
+            },
+        ];
+
+        let report = format_console_report(&rules, 4, 10, 30);
+        assert!(report.contains("2 rules"));
+        assert!(report.contains("4 corrections"));
+        assert!(report.contains("[3x]"));
+        assert!(report.contains("--ammend"));
+        assert!(report.contains("--amend"));
+        assert!(report.contains("Error: error: unexpected argument"));
+    }
+
+    #[test]
+    fn test_write_rules_file_markdown() {
+        let rules = vec![CorrectionRule {
+            wrong_pattern: "git commit --ammend".to_string(),
+            right_pattern: "git commit --amend".to_string(),
+            error_type: ErrorType::UnknownFlag,
+            occurrences: 3,
+            base_command: "git commit".to_string(),
+            example_error: "error: unexpected argument '--ammend'".to_string(),
+        }];
+
+        let temp_dir = tempfile::tempdir().unwrap();
+        let path = temp_dir.path().join("cli-corrections.md");
+        let path_str = path.to_str().unwrap();
+
+        write_rules_file(&rules, path_str).unwrap();
+
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.contains("# CLI Corrections"));
+        assert!(content.contains("## Git commit"));
+        assert!(content.contains("Use `git commit --amend` not `git commit --ammend`"));
+        assert!(content.contains("(seen 3x)"));
+    }
+}