✨ Add AI-powered code review functionality

Implement a new 'review' command that provides AI-powered code reviews
for staged changes. This adds the ability to get professional, constructive
feedback on code changes before committing.

The implementation includes:
- New review command in CLI with options to print or display results
- GeneratedReview model for structured code review feedback
- Code review prompt generation and token optimization
- Colorized terminal output with categorized feedback
- Unit tests for review formatting

The review output includes summary, code quality assessment, positive
aspects, issues identified, and suggestions for improvement - all
formatted with helpful colors and emojis for better readability.

Author: hyperb1iss

src/cli.rs

@@ -5,8 +5,8 @@ use crate::common::CommonParams;
 use crate::llm::get_available_provider_names;
 use crate::log_debug;
 use crate::ui;
-use clap::builder::{styling::AnsiColor, Styles};
-use clap::{crate_version, Parser, Subcommand};
+use clap::builder::{Styles, styling::AnsiColor};
+use clap::{Parser, Subcommand, crate_version};
 
 const LOG_FILE: &str = "git-iris-debug.log";
 
@@ -74,6 +74,19 @@ pub enum Commands {
         #[arg(long, help = "Skip verification steps (pre/post commit hooks)")]
         no_verify: bool,
     },
+    /// Review staged changes and provide feedback
+    #[command(
+        about = "Review staged changes using AI",
+        long_about = "Generate a detailed code review of staged changes using AI based on the current Git context."
+    )]
+    Review {
+        #[command(flatten)]
+        common: CommonParams,
+
+        /// Print the generated review to stdout and exit
+        #[arg(short, long, help = "Print the generated review to stdout and exit")]
+        print: bool,
+    },
     /// Configure the AI-assisted Git commit message generator
     #[command(about = "Configure the AI-assisted Git commit message generator")]
     Config {
@@ -200,7 +213,11 @@ pub async fn handle_command(command: Commands) -> anyhow::Result<()> {
         } => {
             log_debug!(
                 "Handling 'gen' command with common: {:?}, auto_commit: {}, no_gitmoji: {}, print: {}, no_verify: {}",
-                common, auto_commit, no_gitmoji, print, no_verify
+                common,
+                auto_commit,
+                no_gitmoji,
+                print,
+                no_verify
             );
 
             ui::print_version(crate_version!());
@@ -217,7 +234,11 @@ pub async fn handle_command(command: Commands) -> anyhow::Result<()> {
         } => {
             log_debug!(
                 "Handling 'config' command with common: {:?}, api_key: {:?}, model: {:?}, token_limit: {:?}, param: {:?}",
-                common, api_key, model, token_limit, param
+                common,
+                api_key,
+                model,
+                token_limit,
+                param
             );
             commands::handle_config_command(common, api_key, model, token_limit, param)?;
         }
@@ -243,6 +264,16 @@ pub async fn handle_command(command: Commands) -> anyhow::Result<()> {
             );
             changes::handle_release_notes_command(common, from, to).await?;
         }
+        Commands::Review { common, print } => {
+            log_debug!(
+                "Handling 'review' command with common: {:?}, print: {}",
+                common,
+                print
+            );
+            ui::print_version(crate_version!());
+            println!();
+            commit::review::handle_review_command(common, print).await?;
+        }
     }
 
     Ok(())

src/commit/mod.rs

@@ -1,10 +1,12 @@
 mod cli;
 mod relevance;
+pub mod review;
 
 pub mod prompt;
 pub mod service;
 
 pub use cli::handle_gen_command;
+pub use review::handle_review_command;
 use git2::FileMode;
 pub use service::IrisCommitService;
 

src/commit/prompt.rs

@@ -1,7 +1,8 @@
 use crate::common::get_combined_instructions;
 use crate::config::Config;
 use crate::context::{
-    ChangeType, CommitContext, GeneratedMessage, ProjectMetadata, RecentCommit, StagedFile,
+    ChangeType, CommitContext, GeneratedMessage, GeneratedReview, ProjectMetadata, RecentCommit,
+    StagedFile,
 };
 use crate::gitmoji::{apply_gitmoji, get_gitmoji_list};
 
@@ -193,3 +194,108 @@ pub fn process_commit_message(message: String, use_gitmoji: bool) -> String {
         message
     }
 }
+
+/// Creates a system prompt for code review generation
+pub fn create_review_system_prompt(config: &Config) -> anyhow::Result<String> {
+    let review_schema = schemars::schema_for!(GeneratedReview);
+    let review_schema_str = serde_json::to_string_pretty(&review_schema)?;
+
+    let mut prompt = String::from(
+        "You are an AI assistant specializing in code reviews. \
+        Your task is to provide a comprehensive, professional, and constructive review of the code changes provided.
+
+        Work step-by-step and follow these guidelines exactly:
+
+        1. Analyze the code changes carefully, focusing on:
+           - Code quality and readability
+           - Potential bugs or errors
+           - Architecture and design patterns
+           - Performance implications
+           - Security considerations
+           - Maintainability and testability
+
+        2. Provide constructive feedback:
+           - Be specific and actionable in your suggestions
+           - Point out both strengths and areas for improvement
+           - Explain why certain patterns or practices are problematic
+           - Suggest alternative approaches when appropriate
+
+        3. Focus on substantive issues:
+           - Prioritize significant issues over minor stylistic concerns
+           - Consider the context of the codebase and changes
+           - Note potential edge cases or scenarios that might not be handled
+
+        4. Be professional and constructive:
+           - Frame feedback positively and constructively
+           - Focus on the code, not the developer
+           - Acknowledge good practices and improvements
+
+        Your review should be based entirely on the information provided in the context, without any speculation or assumptions.
+      ");
+
+    prompt.push_str(get_combined_instructions(config).as_str());
+
+    prompt.push_str("
+        Your response must be a valid JSON object with the following structure:
+
+        {
+          \"summary\": \"A brief summary of the changes and their quality\",
+          \"code_quality\": \"An assessment of the overall code quality\",
+          \"suggestions\": [\"Suggestion 1\", \"Suggestion 2\", ...],
+          \"issues\": [\"Issue 1\", \"Issue 2\", ...],
+          \"positive_aspects\": [\"Positive aspect 1\", \"Positive aspect 2\", ...]
+        }
+
+        Follow these steps to generate the code review:
+
+        1. Analyze the provided context, including staged changes, recent commits, and project metadata.
+        2. Evaluate the code quality, looking for potential issues, improvements, and good practices.
+        3. Create a concise summary of the changes and their quality.
+        4. List specific issues found in the code.
+        5. Provide actionable suggestions for improvements.
+        6. Acknowledge positive aspects and good practices in the code.
+        7. Construct the final JSON object with all components.
+
+        Here's a minimal example of the expected output format:
+
+        {
+          \"summary\": \"The changes implement a new authentication system with good separation of concerns, but lacks proper error handling in several places.\",
+          \"code_quality\": \"The code is generally well-structured with clear naming conventions. The architecture follows established patterns, but there are some inconsistencies in error handling approaches.\",
+          \"suggestions\": [\"Consider implementing a consistent error handling strategy across all authentication operations\", \"Add unit tests for edge cases in the token validation logic\"],
+          \"issues\": [\"Missing error handling in the user registration flow\", \"Potential race condition in token refresh mechanism\"],
+          \"positive_aspects\": [\"Good separation of concerns with clear service boundaries\", \"Consistent naming conventions throughout the added components\"]
+        }
+
+        Ensure that your response is a valid JSON object matching this structure.
+        "
+    );
+
+    prompt.push_str(&review_schema_str);
+
+    Ok(prompt)
+}
+
+/// Creates a user prompt for code review generation
+pub fn create_review_user_prompt(context: &CommitContext) -> String {
+    let scorer = RelevanceScorer::new();
+    let relevance_scores = scorer.score(context);
+    let detailed_changes = format_detailed_changes(&context.staged_files, &relevance_scores);
+
+    let prompt = format!(
+        "Based on the following context, generate a code review:\n\n\
+        Branch: {}\n\n\
+        Recent commits:\n{}\n\n\
+        Staged changes:\n{}\n\n\
+        Project metadata:\n{}\n\n\
+        Detailed changes:\n{}",
+        context.branch,
+        format_recent_commits(&context.recent_commits),
+        format_staged_files(&context.staged_files, &relevance_scores),
+        format_project_metadata(&context.project_metadata),
+        detailed_changes
+    );
+
+    log_debug!("Review context details:\n{}", detailed_changes);
+
+    prompt
+}

src/commit/review.rs

@@ -0,0 +1,83 @@
+use super::service::IrisCommitService;
+use crate::common::CommonParams;
+use crate::config::Config;
+use crate::llm_providers::LLMProviderType;
+use crate::messages;
+use crate::ui;
+use anyhow::{Context, Result};
+use std::str::FromStr;
+use std::sync::Arc;
+use colored::Colorize;
+
+/// Handles the review command which generates an AI code review of staged changes
+pub async fn handle_review_command(
+    common: CommonParams,
+    print: bool,
+) -> Result<()> {
+    let mut config = Config::load()?;
+    common.apply_to_config(&mut config)?;
+    let current_dir = std::env::current_dir()?;
+
+    let provider_type = LLMProviderType::from_str(&config.default_provider)?;
+
+    let service = Arc::new(
+        IrisCommitService::new(
+            config.clone(),
+            &current_dir.clone(),
+            provider_type,
+            false, // gitmoji not needed for review
+            false, // verification not needed for review
+        )
+        .context("Failed to create IrisCommitService")?,
+    );
+
+    // Check environment prerequisites
+    if let Err(e) = service.check_environment() {
+        ui::print_error(&format!("Error: {e}"));
+        ui::print_info("\nPlease ensure the following:");
+        ui::print_info("1. Git is installed and accessible from the command line.");
+        ui::print_info("2. You are running this command from within a Git repository.");
+        ui::print_info("3. You have set up your configuration using 'git-iris config'.");
+        return Err(e);
+    }
+
+    let git_info = service.get_git_info().await?;
+
+    if git_info.staged_files.is_empty() {
+        ui::print_warning(
+            "No staged changes. Please stage your changes before generating a review.",
+        );
+        ui::print_info("You can stage changes using 'git add <file>' or 'git add .'");
+        return Ok(());
+    }
+
+    let effective_instructions = common
+        .instructions
+        .unwrap_or_else(|| config.instructions.clone());
+    let preset_str = common.preset.as_deref().unwrap_or("");
+
+    // Create and start the spinner
+    let spinner = ui::create_spinner("");
+    let random_message = messages::get_waiting_message();
+    spinner.set_message(format!("{} {}", "🔮".cyan(), random_message.text));
+
+    // Generate the code review
+    let review = service
+        .generate_review(preset_str, &effective_instructions)
+        .await?;
+
+    // Stop the spinner
+    spinner.finish_and_clear();
+
+    // Print the review to stdout or save to file if requested
+    if print {
+        // Just print to stdout
+        println!("\n{}", review.format());
+    } else {
+        // Add a fancy version header
+        println!("\n{} {}\n", "🔮".cyan(), "Git-Iris Code Review".bright_magenta().bold());
+        println!("{}", review.format());
+    }
+
+    Ok(())
+}