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

// Generate code from specification
// Adapted from automation/src/commands/generate.rs

use super::Command;
use crate::error::{CliError, CliResult};
use crate::output::OutputStyle;
use std::fs;
use std::path::{Path, PathBuf};

/// Generate code from a specification
pub struct GenCommand {
    pub spec_file: String,
}

impl GenCommand {
    pub fn new(spec_file: String) -> Self {
        Self { spec_file }
    }

    /// Validate that the spec file exists and is readable
    fn validate_spec(&self) -> CliResult<PathBuf> {
        let spec_path = Path::new(&self.spec_file);

        // Check if file exists
        if !spec_path.exists() {
            return Err(CliError::InvalidArgument {
                message: format!("Spec file not found: {}", self.spec_file),
            });
        }

        // Check if it's a file (not a directory)
        if !spec_path.is_file() {
            return Err(CliError::InvalidArgument {
                message: format!("Spec path is not a file: {}", self.spec_file),
            });
        }

        // Check if file is readable
        match fs::metadata(spec_path) {
            Ok(_) => Ok(spec_path.to_path_buf()),
            Err(e) => Err(CliError::Io(e)),
        }
    }

    /// Load and parse the spec file
    fn load_spec(&self, spec_path: &Path) -> CliResult<String> {
        match fs::read_to_string(spec_path) {
            Ok(content) => {
                // Basic validation: spec should not be empty
                if content.trim().is_empty() {
                    return Err(CliError::InvalidArgument {
                        message: "Spec file is empty".to_string(),
                    });
                }
                Ok(content)
            }
            Err(e) => Err(CliError::Io(e)),
        }
    }

    /// Generate code from the spec
    fn generate_code(&self, _spec_content: &str) -> CliResult<()> {
        // TODO: Implement actual code generation
        // For now, this is a placeholder that shows the generation flow
        Ok(())
    }
}

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

        // Validate spec file
        let spec_path = self.validate_spec()?;
        println!(
            "{}",
            style.info(&format!("Loading spec: {}", self.spec_file))
        );

        // Load spec content
        let spec_content = self.load_spec(&spec_path)?;
        println!("{}", style.success("Spec loaded successfully"));

        // Generate code
        self.generate_code(&spec_content)?;
        println!("{}", style.success("Code generation complete"));

        Ok(())
    }
}