ricecoder 0.1.72

Terminal-first, spec-driven coding assistant that understands your project before generating code
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// Interactive chat mode
// Adapted from automation/src/cli/prompts.rs

use super::Command;
use crate::chat::ChatSession;
use crate::error::{CliError, CliResult};
use crate::output::OutputStyle;
use ricecoder_storage::PathResolver;

/// Interactive chat mode
pub struct ChatCommand {
    pub message: Option<String>,
    pub provider: Option<String>,
    pub model: Option<String>,
}

impl ChatCommand {
    pub fn new(message: Option<String>, provider: Option<String>, model: Option<String>) -> Self {
        Self {
            message,
            provider,
            model,
        }
    }

    /// Validate provider is supported
    fn validate_provider(&self) -> CliResult<String> {
        let provider = self.provider.as_deref().unwrap_or("openai");

        // List of supported providers
        let supported = ["openai", "anthropic", "local"];

        if !supported.contains(&provider) {
            return Err(CliError::Provider(format!(
                "Unsupported provider: {}. Supported providers: {}",
                provider,
                supported.join(", ")
            )));
        }

        Ok(provider.to_string())
    }

    /// Validate model is specified or use default
    fn get_model(&self) -> String {
        self.model.as_deref().unwrap_or("gpt-4").to_string()
    }

    /// Load project specs for context
    fn load_project_context(&self) -> CliResult<Vec<String>> {
        let style = OutputStyle::default();
        let mut specs = Vec::new();

        // Resolve project path using PathResolver
        let project_path = PathResolver::resolve_project_path();
        let specs_path = project_path.join("specs");

        // Check for .agent/specs directory (project-level specs)
        if specs_path.exists() {
            println!("{}", style.info("Loading project specs..."));
            // TODO: Actually load specs from .agent/specs/ directory
            specs.push("specs_loaded".to_string());
            println!("{}", style.success("Specs loaded"));
        }

        Ok(specs)
    }

    /// Load knowledge base
    fn load_knowledge_base(&self) -> CliResult<Vec<String>> {
        let style = OutputStyle::default();
        let mut kb = Vec::new();

        // TODO: Load knowledge base from global location
        println!("{}", style.info("Loading knowledge base..."));
        kb.push("kb_loaded".to_string());
        println!("{}", style.success("Knowledge base loaded"));

        Ok(kb)
    }

    /// Process initial message
    fn process_initial_message(&self, message: &str, session: &mut ChatSession) -> CliResult<()> {
        let style = OutputStyle::default();

        // Add user message to history
        session.add_message("user".to_string(), message.to_string());

        println!();
        println!("{}", style.prompt("r["));
        println!("{}", message);
        println!("{}", style.info("Processing message..."));

        // TODO: Send to AI provider and get response
        let response = "This is a placeholder response. Full AI integration coming soon.";
        session.add_message("assistant".to_string(), response.to_string());

        println!("{}", style.success(response));
        println!();

        Ok(())
    }

    /// Enter interactive chat loop
    fn run_chat_loop(&self, session: &mut ChatSession) -> CliResult<()> {
        let style = OutputStyle::default();

        // If initial message provided, process it
        if let Some(msg) = &self.message {
            self.process_initial_message(msg, session)?;
        } else {
            // Interactive mode
            println!();
            println!("{}", style.header("RiceCoder Chat Mode"));
            println!("{}", style.info("Type 'exit' to quit, 'help' for commands"));
            println!();

            // Use the chat session's built-in REPL
            session.start()?;
        }

        Ok(())
    }
}

impl Command for ChatCommand {
    fn execute(&self) -> CliResult<()> {
        let style = OutputStyle::default();

        // Validate provider
        let provider = self.validate_provider()?;
        let model = self.get_model();

        println!("{}", style.section("Chat Configuration"));
        println!("{}", style.key_value("Provider", &provider));
        println!("{}", style.key_value("Model", &model));
        println!();

        // Load project context
        let _specs = self.load_project_context()?;
        let _kb = self.load_knowledge_base()?;

        // Create chat session
        let mut session = ChatSession::new(provider, model);

        // Run chat loop
        self.run_chat_loop(&mut session)?;

        println!();
        println!("{}", style.success("Chat session ended"));

        Ok(())
    }
}