terraphim_agent 1.16.34

Terraphim AI Agent CLI - Command-line interface with interactive REPL and ASCII graph visualization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

// Simplified test that only tests command parsing without full handler dependencies
// Tests match the actual FileSubcommand variants: Search, List, Info
#[cfg(test)]
mod tests {
    use std::str::FromStr;

    // Test basic command parsing for file operations
    #[test]
    #[cfg(feature = "repl-file")]
    fn test_file_command_parsing_basic() {
        use terraphim_agent::repl::commands::ReplCommand;

        // Test file search command
        let result = ReplCommand::from_str("/file search \"test query\"");
        assert!(result.is_ok());

        if let ReplCommand::File { subcommand: _ } = result.unwrap() {
            // We can't access the subcommand variants directly due to feature gating
            // but we can verify it parsed as a File command
            println!("✅ File search command parsed successfully");
        } else {
            panic!("Expected File command");
        }
    }

    #[test]
    #[cfg(feature = "repl-file")]
    fn test_file_command_help_available() {
        use terraphim_agent::repl::commands::ReplCommand;

        // Test that file command is in available commands
        let commands = ReplCommand::available_commands();
        assert!(
            commands.contains(&"file"),
            "file command should be in available commands"
        );

        // Test that help text exists
        let help_text = ReplCommand::get_command_help("file");
        assert!(help_text.is_some(), "file command should have help text");

        let help = help_text.unwrap();
        // Help mentions "File operations" (case-insensitive check)
        assert!(
            help.to_lowercase().contains("file operations"),
            "help should mention file operations, got: {}",
            help
        );

        println!("✅ File command help available: {}", help);
    }

    #[test]
    #[cfg(feature = "repl-file")]
    fn test_variations_of_file_commands() {
        use terraphim_agent::repl::commands::ReplCommand;

        // Test only the implemented FileSubcommand variants: Search, List, Info
        let test_commands = vec![
            "/file search \"rust async\"",
            "/file list",
            "/file info ./main.rs",
        ];

        for cmd in test_commands {
            let result = ReplCommand::from_str(cmd);
            assert!(result.is_ok(), "Failed to parse command: {}", cmd);

            match result.unwrap() {
                ReplCommand::File { .. } => {
                    println!("✅ Successfully parsed: {}", cmd);
                }
                _ => panic!("Expected File command for: {}", cmd),
            }
        }
    }

    #[test]
    #[cfg(feature = "repl-file")]
    fn test_invalid_file_commands() {
        use terraphim_agent::repl::commands::ReplCommand;

        let invalid_commands = vec![
            "/file",                          // missing subcommand
            "/file search",                   // missing query
            "/file info",                     // missing path
            "/file invalid_subcommand ./src", // invalid subcommand
        ];

        for cmd in invalid_commands {
            let result = ReplCommand::from_str(cmd);
            assert!(
                result.is_err(),
                "Expected error for invalid command: {}",
                cmd
            );
            println!("✅ Correctly rejected invalid command: {}", cmd);
        }
    }

    #[test]
    #[cfg(feature = "repl-file")]
    fn test_file_command_with_various_flags() {
        use terraphim_agent::repl::commands::ReplCommand;

        // Test commands with the implemented subcommands
        // Note: Current implementation only supports basic search, list, info
        let complex_commands = vec![
            "/file search \"async rust\"",
            "/file list",
            "/file info ./src/main.rs",
        ];

        for cmd in complex_commands {
            let result = ReplCommand::from_str(cmd);
            assert!(result.is_ok(), "Failed to parse complex command: {}", cmd);

            match result.unwrap() {
                ReplCommand::File { .. } => {
                    println!("✅ Successfully parsed complex command: {}", cmd);
                }
                _ => panic!("Expected File command for: {}", cmd),
            }
        }
    }
}