Struct VibeMode 

pub struct VibeMode { /* private fields */ }

Vibe Mode for free-form exploration and rapid prototyping

Vibe Mode provides capabilities for:

• Natural language code generation without formal specs
• Rapid iteration and exploration
• Spec conversion for transitioning to spec-driven development
• Warnings about limitations and best practices

Implementations

impl VibeMode

pub fn new() -> Self

Create a new Vibe Mode instance

pub fn with_config(config: ModeConfig) -> Self

Create a Vibe Mode with custom configuration

pub fn generate_code_from_description( &self, description: &str, ) -> Result<String>

Generate code from natural language without formal specs

This method generates code directly from natural language descriptions without requiring formal specifications.

pub fn iterate_rapidly(&self, iteration_input: &str) -> Result<String>

Support rapid iteration by accepting natural language input

This method enables quick prototyping by accepting natural language input and generating code without formal review cycles.

pub fn generate_with_iterations( &self, description: &str, iterations: usize, ) -> Result<String>

Generate code with multiple iterations

This method supports generating code through multiple rapid iterations, allowing developers to refine and improve the generated code.

pub fn accept_natural_language(&self, input: &str) -> Result<String>

Accept natural language input and generate code

This method is the core of Vibe Mode - it accepts natural language input without requiring formal specifications and generates code.

pub fn convert_to_specs(&self, project_code: &str) -> Result<String>

Convert a Vibe Mode project to spec-driven format

This method converts existing code and context from Vibe Mode to a formal spec-driven development format.

pub fn preserve_code_and_context( &self, code: &str, context: &ModeContext, ) -> Result<String>

Preserve all code and context during conversion

This method ensures that all code and context is preserved when converting from Vibe Mode to spec-driven format.

pub fn generate_specs_from_code(&self, code: &str) -> Result<String>

Generate initial specs from code

This method analyzes code and generates initial specifications that can be refined and expanded.

pub fn convert_project_to_specs( &self, code: &str, context: &ModeContext, ) -> Result<String>

Support converting Vibe Mode projects to spec-driven format

This method provides a complete conversion workflow from Vibe Mode to spec-driven development.

pub fn generate_warnings(&self) -> Vec<String>

Generate warnings about Vibe Mode limitations

This method creates warnings about the limitations of Vibe Mode and best practices for using it.

pub fn generate_specific_warnings(&self, context: &str) -> Vec<String>

Generate warnings about specific limitations

This method generates warnings about specific limitations based on the context of use.

pub fn format_warnings(&self, warnings: &[String]) -> String

Display warnings in a formatted way

This method formats warnings for display to the user.

pub fn add_warnings_to_response(&self, response: &mut ModeResponse)

Include warnings in all responses

This method adds warnings to a response to inform users about Vibe Mode limitations.

pub fn add_specific_warnings_to_response( &self, response: &mut ModeResponse, context: &str, )

Include specific warnings based on context

This method adds context-specific warnings to a response.

pub fn validate_operation(&self, operation: &Operation) -> Result<()>

Validate that an operation is allowed in Vibe Mode

This method checks if an operation can be executed in Vibe Mode.

pub fn provide_best_practices(&self) -> Vec<String>

Provide guidance on best practices

This method generates guidance on how to best use Vibe Mode.

Trait Implementations

impl Clone for VibeMode

fn clone(&self) -> VibeMode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VibeMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for VibeMode

fn default() -> Self

Returns the “default value” for a type.

impl Mode for VibeMode

fn id(&self) -> &str

Mode identifier (e.g., “code”, “ask”, “vibe”)

fn name(&self) -> &str

Human-readable name

fn description(&self) -> &str

Mode description

fn system_prompt(&self) -> &str

Get system prompt for this mode

fn process<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, input: &'life1 str, context: &'life2 ModeContext, ) -> Pin<Box<dyn Future<Output = Result<ModeResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Process user input in this mode

fn capabilities(&self) -> Vec<Capability>

Get mode-specific capabilities

fn config(&self) -> &ModeConfig

Get mode configuration

fn can_execute(&self, operation: &Operation) -> bool

Validate if operation is allowed in this mode

fn constraints(&self) -> ModeConstraints

Get mode-specific constraints