814 lines
29 KiB
Rust
814 lines
29 KiB
Rust
use anyhow::Result;
|
|
use clap::Parser;
|
|
use g3_config::Config;
|
|
use g3_core::{project::Project, ui_writer::UiWriter, Agent};
|
|
use rustyline::error::ReadlineError;
|
|
use rustyline::DefaultEditor;
|
|
use std::path::PathBuf;
|
|
use tokio_util::sync::CancellationToken;
|
|
use tracing::{error, info};
|
|
|
|
mod retro_tui;
|
|
mod tui;
|
|
mod ui_writer_impl;
|
|
mod theme;
|
|
use retro_tui::RetroTui;
|
|
use tui::SimpleOutput;
|
|
use ui_writer_impl::{ConsoleUiWriter, RetroTuiWriter};
|
|
use theme::ColorTheme;
|
|
|
|
#[derive(Parser)]
|
|
#[command(name = "g3")]
|
|
#[command(about = "A modular, composable AI coding agent")]
|
|
#[command(version)]
|
|
pub struct Cli {
|
|
/// Enable verbose logging
|
|
#[arg(short, long)]
|
|
pub verbose: bool,
|
|
|
|
/// Show the system prompt being sent to the LLM
|
|
#[arg(long)]
|
|
pub show_prompt: bool,
|
|
|
|
/// Show the generated code before execution
|
|
#[arg(long)]
|
|
pub show_code: bool,
|
|
|
|
/// Configuration file path
|
|
#[arg(short, long)]
|
|
pub config: Option<String>,
|
|
|
|
/// Workspace directory (defaults to current directory)
|
|
#[arg(short, long)]
|
|
pub workspace: Option<PathBuf>,
|
|
|
|
/// Task to execute (if provided, runs in single-shot mode instead of interactive)
|
|
pub task: Option<String>,
|
|
|
|
/// Enable autonomous mode with coach-player feedback loop
|
|
#[arg(long)]
|
|
pub autonomous: bool,
|
|
|
|
/// Maximum number of turns in autonomous mode (default: 5)
|
|
#[arg(long, default_value = "5")]
|
|
pub max_turns: usize,
|
|
|
|
/// Use retro terminal UI (inspired by 80s sci-fi)
|
|
#[arg(long)]
|
|
pub retro: bool,
|
|
|
|
/// Color theme for retro mode (default, dracula, or path to theme file)
|
|
#[arg(long, value_name = "THEME")]
|
|
pub theme: Option<String>,
|
|
}
|
|
|
|
pub async fn run() -> Result<()> {
|
|
let cli = Cli::parse();
|
|
|
|
// Only initialize logging if not in retro mode
|
|
if !cli.retro {
|
|
// Initialize logging with filtering
|
|
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
|
|
|
|
// Create a filter that suppresses llama_cpp logs unless in verbose mode
|
|
let filter = if cli.verbose {
|
|
EnvFilter::from_default_env()
|
|
.add_directive(format!("{}=debug", env!("CARGO_PKG_NAME")).parse().unwrap())
|
|
.add_directive("g3_core=debug".parse().unwrap())
|
|
.add_directive("g3_cli=debug".parse().unwrap())
|
|
.add_directive("g3_execution=debug".parse().unwrap())
|
|
.add_directive("g3_providers=debug".parse().unwrap())
|
|
} else {
|
|
EnvFilter::from_default_env()
|
|
.add_directive(format!("{}=info", env!("CARGO_PKG_NAME")).parse().unwrap())
|
|
.add_directive("g3_core=info".parse().unwrap())
|
|
.add_directive("g3_cli=info".parse().unwrap())
|
|
.add_directive("g3_execution=info".parse().unwrap())
|
|
.add_directive("g3_providers=info".parse().unwrap())
|
|
.add_directive("llama_cpp=off".parse().unwrap()) // Suppress all llama_cpp logs
|
|
.add_directive("llama=off".parse().unwrap()) // Suppress all llama.cpp logs
|
|
};
|
|
|
|
tracing_subscriber::registry()
|
|
.with(tracing_subscriber::fmt::layer())
|
|
.with(filter)
|
|
.init();
|
|
} else {
|
|
// In retro mode, we don't want any logging output to interfere with the TUI
|
|
// We'll use a no-op subscriber
|
|
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
|
|
|
|
// Create a filter that suppresses ALL logs in retro mode
|
|
let filter = EnvFilter::from_default_env().add_directive("off".parse().unwrap()); // Turn off all logging
|
|
|
|
tracing_subscriber::registry().with(filter).init();
|
|
}
|
|
|
|
if !cli.retro {
|
|
info!("Starting G3 AI Coding Agent");
|
|
}
|
|
|
|
// Set up workspace directory
|
|
let workspace_dir = if let Some(ws) = cli.workspace {
|
|
ws
|
|
} else if cli.autonomous {
|
|
// For autonomous mode, use G3_WORKSPACE env var or default
|
|
setup_workspace_directory()?
|
|
} else {
|
|
// Default to current directory for interactive/single-shot mode
|
|
std::env::current_dir()?
|
|
};
|
|
|
|
// Create project model
|
|
let project = if cli.autonomous {
|
|
Project::new_autonomous(workspace_dir.clone())?
|
|
} else {
|
|
Project::new(workspace_dir.clone())
|
|
};
|
|
|
|
// Ensure workspace exists and enter it
|
|
project.ensure_workspace_exists()?;
|
|
project.enter_workspace()?;
|
|
|
|
if !cli.retro {
|
|
info!("Using workspace: {}", project.workspace().display());
|
|
}
|
|
|
|
// Load configuration
|
|
let config = Config::load(cli.config.as_deref())?;
|
|
|
|
// Initialize agent
|
|
let ui_writer = ConsoleUiWriter::new();
|
|
let mut agent = if cli.autonomous {
|
|
Agent::new_autonomous(config.clone(), ui_writer).await?
|
|
} else {
|
|
Agent::new(config.clone(), ui_writer).await?
|
|
};
|
|
|
|
// Execute task, autonomous mode, or start interactive mode
|
|
if cli.autonomous {
|
|
// Autonomous mode with coach-player feedback loop
|
|
if !cli.retro {
|
|
info!("Starting autonomous mode");
|
|
}
|
|
run_autonomous(
|
|
agent,
|
|
project,
|
|
cli.show_prompt,
|
|
cli.show_code,
|
|
cli.max_turns,
|
|
)
|
|
.await?;
|
|
} else if let Some(task) = cli.task {
|
|
// Single-shot mode
|
|
if !cli.retro {
|
|
info!("Executing task: {}", task);
|
|
}
|
|
let output = SimpleOutput::new();
|
|
let result = agent
|
|
.execute_task_with_timing(&task, None, false, cli.show_prompt, cli.show_code, true)
|
|
.await?;
|
|
output.print_markdown(&result);
|
|
} else {
|
|
// Interactive mode (default)
|
|
if !cli.retro {
|
|
info!("Starting interactive mode");
|
|
}
|
|
|
|
if cli.retro {
|
|
// Use retro terminal UI
|
|
run_interactive_retro(config, cli.show_prompt, cli.show_code, cli.theme).await?;
|
|
} else {
|
|
// Use standard terminal UI
|
|
let output = SimpleOutput::new();
|
|
output.print(&format!("📁 Workspace: {}", project.workspace().display()));
|
|
run_interactive(agent, cli.show_prompt, cli.show_code).await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_interactive_retro(config: Config, show_prompt: bool, show_code: bool, theme_name: Option<String>) -> Result<()> {
|
|
use crossterm::event::{self, Event, KeyCode, KeyModifiers};
|
|
use std::time::Duration;
|
|
|
|
// Set environment variable to suppress println in other crates
|
|
std::env::set_var("G3_RETRO_MODE", "1");
|
|
|
|
// Load the color theme
|
|
let theme = match ColorTheme::load(theme_name.as_deref()) {
|
|
Ok(t) => t,
|
|
Err(e) => {
|
|
eprintln!("Failed to load theme: {}. Using default.", e);
|
|
ColorTheme::default()
|
|
}
|
|
};
|
|
|
|
// Initialize the retro terminal UI
|
|
let tui = RetroTui::start(theme).await?;
|
|
|
|
// Create agent with RetroTuiWriter
|
|
let ui_writer = RetroTuiWriter::new(tui.clone());
|
|
let mut agent = Agent::new(config, ui_writer).await?;
|
|
|
|
// Display initial system messages
|
|
tui.output("SYSTEM: AGENT ONLINE\n\n");
|
|
tui.output("SYSTEM: READY FOR INPUT\n\n");
|
|
tui.output("\n\n");
|
|
|
|
// Display provider and model information
|
|
match agent.get_provider_info() {
|
|
Ok((provider, model)) => {
|
|
tui.update_provider_info(&provider, &model);
|
|
}
|
|
Err(e) => {
|
|
tui.update_provider_info("ERROR", &e.to_string());
|
|
}
|
|
}
|
|
|
|
// Track multiline input
|
|
let mut multiline_buffer = String::new();
|
|
let mut in_multiline = false;
|
|
|
|
// Main event loop
|
|
loop {
|
|
// Update context window display
|
|
let context = agent.get_context_window();
|
|
tui.update_context(
|
|
context.used_tokens,
|
|
context.total_tokens,
|
|
context.percentage_used(),
|
|
);
|
|
|
|
// Poll for keyboard events
|
|
if event::poll(Duration::from_millis(50))? {
|
|
if let Event::Key(key) = event::read()? {
|
|
match key.code {
|
|
KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.exit();
|
|
break;
|
|
}
|
|
KeyCode::Char('d') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.exit();
|
|
break;
|
|
}
|
|
// Emacs/bash-like shortcuts
|
|
KeyCode::Char('a') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.cursor_home();
|
|
}
|
|
KeyCode::Char('e') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.cursor_end();
|
|
}
|
|
KeyCode::Char('w') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.delete_word();
|
|
}
|
|
KeyCode::Char('k') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.delete_to_end();
|
|
}
|
|
KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
// Delete from beginning to cursor (similar to Ctrl-K but opposite direction)
|
|
let (input_buffer, cursor_pos) = tui.get_input_state();
|
|
if cursor_pos > 0 {
|
|
let after = input_buffer.chars().skip(cursor_pos).collect::<String>();
|
|
tui.update_input(&after);
|
|
tui.cursor_home();
|
|
}
|
|
}
|
|
KeyCode::Left => {
|
|
tui.cursor_left();
|
|
}
|
|
KeyCode::Right => {
|
|
tui.cursor_right();
|
|
}
|
|
KeyCode::Home if !key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.cursor_home();
|
|
}
|
|
KeyCode::End if !key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.cursor_end();
|
|
}
|
|
KeyCode::Delete => {
|
|
tui.delete_char();
|
|
}
|
|
KeyCode::Enter => {
|
|
let (input_buffer, _) = tui.get_input_state();
|
|
if !input_buffer.is_empty() {
|
|
// Clear the input for next command
|
|
tui.update_input("");
|
|
let trimmed = input_buffer.trim_end();
|
|
|
|
// Check if line ends with backslash for continuation
|
|
if trimmed.ends_with('\\') {
|
|
// Remove the backslash and add to buffer
|
|
let without_backslash = &trimmed[..trimmed.len() - 1];
|
|
multiline_buffer.push_str(without_backslash);
|
|
multiline_buffer.push('\n');
|
|
in_multiline = true;
|
|
tui.status("MULTILINE INPUT");
|
|
continue;
|
|
}
|
|
|
|
// If we're in multiline mode and no backslash, this is the final line
|
|
let final_input = if in_multiline {
|
|
multiline_buffer.push_str(&input_buffer);
|
|
in_multiline = false;
|
|
let result = multiline_buffer.clone();
|
|
multiline_buffer.clear();
|
|
tui.status("READY");
|
|
result
|
|
} else {
|
|
input_buffer.clone()
|
|
};
|
|
|
|
let input = final_input.trim().to_string();
|
|
if input.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
if input == "exit" || input == "quit" {
|
|
tui.exit();
|
|
break;
|
|
}
|
|
|
|
// Execute the task
|
|
tui.output(&format!("> {}", input));
|
|
tui.status("PROCESSING");
|
|
|
|
match agent
|
|
.execute_task_with_timing(
|
|
&input,
|
|
None,
|
|
false,
|
|
show_prompt,
|
|
show_code,
|
|
true,
|
|
)
|
|
.await
|
|
{
|
|
Ok(response) => {
|
|
tui.output(&response);
|
|
tui.status("READY");
|
|
}
|
|
Err(e) => {
|
|
tui.error(&format!("Task execution failed: {}", e));
|
|
tui.status("ERROR");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
KeyCode::Char(c) => {
|
|
tui.insert_char(c);
|
|
}
|
|
KeyCode::Backspace => {
|
|
tui.backspace();
|
|
}
|
|
KeyCode::Up => {
|
|
tui.scroll_up();
|
|
}
|
|
KeyCode::Down => {
|
|
tui.scroll_down();
|
|
}
|
|
KeyCode::PageUp => {
|
|
tui.scroll_page_up();
|
|
}
|
|
KeyCode::PageDown => {
|
|
tui.scroll_page_down();
|
|
}
|
|
KeyCode::Home if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.scroll_home(); // Ctrl+Home for scrolling to top
|
|
}
|
|
KeyCode::End if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
tui.scroll_end(); // Ctrl+End for scrolling to bottom
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Small delay to prevent CPU spinning
|
|
tokio::time::sleep(Duration::from_millis(10)).await;
|
|
}
|
|
|
|
tui.output("SYSTEM: SHUTDOWN INITIATED");
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_interactive<W: UiWriter>(
|
|
mut agent: Agent<W>,
|
|
show_prompt: bool,
|
|
show_code: bool,
|
|
) -> Result<()> {
|
|
let output = SimpleOutput::new();
|
|
|
|
output.print("");
|
|
output.print("🤖 G3 AI Coding Agent - Interactive Mode");
|
|
output.print(
|
|
"I solve problems by writing and executing code. Tell me what you need to accomplish!",
|
|
);
|
|
output.print("");
|
|
|
|
// Display provider and model information
|
|
match agent.get_provider_info() {
|
|
Ok((provider, model)) => {
|
|
output.print(&format!("🔧 Provider: {} | Model: {}", provider, model));
|
|
}
|
|
Err(e) => {
|
|
error!("Failed to get provider info: {}", e);
|
|
}
|
|
}
|
|
|
|
output.print("");
|
|
output.print("Type 'exit' or 'quit' to exit, use Up/Down arrows for command history");
|
|
output.print("For multiline input: use \\ at the end of a line to continue");
|
|
output.print("Submit multiline with Enter (without backslash)");
|
|
output.print("");
|
|
|
|
// Initialize rustyline editor with history
|
|
let mut rl = DefaultEditor::new()?;
|
|
|
|
// Try to load history from a file in the user's home directory
|
|
let history_file = dirs::home_dir().map(|mut path| {
|
|
path.push(".g3_history");
|
|
path
|
|
});
|
|
|
|
if let Some(ref history_path) = history_file {
|
|
let _ = rl.load_history(history_path);
|
|
}
|
|
|
|
// Track multiline input
|
|
let mut multiline_buffer = String::new();
|
|
let mut in_multiline = false;
|
|
|
|
loop {
|
|
// Display context window progress bar before each prompt
|
|
display_context_progress(&agent, &output);
|
|
|
|
// Adjust prompt based on whether we're in multi-line mode
|
|
let prompt = if in_multiline { "... > " } else { "g3> " };
|
|
|
|
let readline = rl.readline(prompt);
|
|
match readline {
|
|
Ok(line) => {
|
|
let trimmed = line.trim_end();
|
|
|
|
// Check if line ends with backslash for continuation
|
|
if trimmed.ends_with('\\') {
|
|
// Remove the backslash and add to buffer
|
|
let without_backslash = &trimmed[..trimmed.len() - 1];
|
|
multiline_buffer.push_str(without_backslash);
|
|
multiline_buffer.push('\n');
|
|
in_multiline = true;
|
|
continue;
|
|
}
|
|
|
|
// If we're in multiline mode and no backslash, this is the final line
|
|
if in_multiline {
|
|
multiline_buffer.push_str(&line);
|
|
in_multiline = false;
|
|
// Process the complete multiline input
|
|
let input = multiline_buffer.trim().to_string();
|
|
multiline_buffer.clear();
|
|
|
|
if input.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
// Add complete multiline to history
|
|
rl.add_history_entry(&input)?;
|
|
|
|
if input == "exit" || input == "quit" {
|
|
break;
|
|
}
|
|
|
|
// Process the multiline input
|
|
execute_task(&mut agent, &input, show_prompt, show_code, &output).await;
|
|
} else {
|
|
// Single line input
|
|
let input = line.trim().to_string();
|
|
|
|
if input.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
if input == "exit" || input == "quit" {
|
|
break;
|
|
}
|
|
|
|
// Add to history
|
|
rl.add_history_entry(&input)?;
|
|
|
|
// Process the single line input
|
|
execute_task(&mut agent, &input, show_prompt, show_code, &output).await;
|
|
}
|
|
}
|
|
Err(ReadlineError::Interrupted) => {
|
|
// Ctrl-C pressed
|
|
if in_multiline {
|
|
// Cancel multiline input
|
|
output.print("Multi-line input cancelled");
|
|
multiline_buffer.clear();
|
|
in_multiline = false;
|
|
} else {
|
|
output.print("CTRL-C");
|
|
}
|
|
continue;
|
|
}
|
|
Err(ReadlineError::Eof) => {
|
|
output.print("CTRL-D");
|
|
break;
|
|
}
|
|
Err(err) => {
|
|
error!("Error: {:?}", err);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Save history before exiting
|
|
if let Some(ref history_path) = history_file {
|
|
let _ = rl.save_history(history_path);
|
|
}
|
|
|
|
output.print("👋 Goodbye!");
|
|
Ok(())
|
|
}
|
|
|
|
async fn execute_task<W: UiWriter>(
|
|
agent: &mut Agent<W>,
|
|
input: &str,
|
|
show_prompt: bool,
|
|
show_code: bool,
|
|
output: &SimpleOutput,
|
|
) {
|
|
// Show thinking indicator immediately
|
|
output.print("🤔 Thinking...");
|
|
// Note: flush is handled internally by println
|
|
|
|
// Create cancellation token for this request
|
|
let cancellation_token = CancellationToken::new();
|
|
let cancel_token_clone = cancellation_token.clone();
|
|
|
|
// Execute task with cancellation support
|
|
let execution_result = tokio::select! {
|
|
result = agent.execute_task_with_timing_cancellable(
|
|
input, None, false, show_prompt, show_code, true, cancellation_token
|
|
) => {
|
|
result
|
|
}
|
|
_ = tokio::signal::ctrl_c() => {
|
|
cancel_token_clone.cancel();
|
|
output.print("\n⚠️ Operation cancelled by user (Ctrl+C)");
|
|
return;
|
|
}
|
|
};
|
|
|
|
match execution_result {
|
|
Ok(response) => output.print_markdown(&response),
|
|
Err(e) => {
|
|
if e.to_string().contains("cancelled") {
|
|
output.print("⚠️ Operation cancelled by user");
|
|
} else {
|
|
// Enhanced error logging with detailed information
|
|
error!("=== TASK EXECUTION ERROR ===");
|
|
error!("Error: {}", e);
|
|
|
|
// Log error chain
|
|
let mut source = e.source();
|
|
let mut depth = 1;
|
|
while let Some(err) = source {
|
|
error!(" Caused by [{}]: {}", depth, err);
|
|
source = err.source();
|
|
depth += 1;
|
|
}
|
|
|
|
// Log additional context
|
|
error!("Task input: {}", input);
|
|
error!("Error type: {}", std::any::type_name_of_val(&e));
|
|
|
|
// Display user-friendly error message
|
|
output.print(&format!("❌ Error: {}", e));
|
|
|
|
// If it's a stream error, provide helpful guidance
|
|
if e.to_string().contains("No response received") {
|
|
output.print("💡 This may be a temporary issue. Please try again or check the logs for more details.");
|
|
output.print(" Log files are saved in the 'logs/' directory.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn display_context_progress<W: UiWriter>(agent: &Agent<W>, output: &SimpleOutput) {
|
|
let context = agent.get_context_window();
|
|
output.print_context(
|
|
context.used_tokens,
|
|
context.total_tokens,
|
|
context.percentage_used(),
|
|
);
|
|
}
|
|
|
|
/// Set up the workspace directory for autonomous mode
|
|
/// Uses G3_WORKSPACE environment variable or defaults to ~/tmp/workspace
|
|
fn setup_workspace_directory() -> Result<PathBuf> {
|
|
let workspace_dir = if let Ok(env_workspace) = std::env::var("G3_WORKSPACE") {
|
|
PathBuf::from(env_workspace)
|
|
} else {
|
|
// Default to ~/tmp/workspace
|
|
let home_dir = dirs::home_dir()
|
|
.ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
|
|
home_dir.join("tmp").join("workspace")
|
|
};
|
|
|
|
// Create the directory if it doesn't exist
|
|
if !workspace_dir.exists() {
|
|
std::fs::create_dir_all(&workspace_dir)?;
|
|
let output = SimpleOutput::new();
|
|
output.print(&format!(
|
|
"📁 Created workspace directory: {}",
|
|
workspace_dir.display()
|
|
));
|
|
}
|
|
|
|
Ok(workspace_dir)
|
|
}
|
|
|
|
// Simplified autonomous mode implementation
|
|
async fn run_autonomous(
|
|
mut agent: Agent<ConsoleUiWriter>,
|
|
project: Project,
|
|
show_prompt: bool,
|
|
show_code: bool,
|
|
max_turns: usize,
|
|
) -> Result<()> {
|
|
let output = SimpleOutput::new();
|
|
|
|
output.print("🤖 G3 AI Coding Agent - Autonomous Mode");
|
|
output.print(&format!(
|
|
"📁 Using workspace: {}",
|
|
project.workspace().display()
|
|
));
|
|
|
|
// Check if requirements exist
|
|
if !project.has_requirements() {
|
|
output.print("❌ Error: requirements.md not found in workspace directory");
|
|
output.print(" Please create a requirements.md file with your project requirements at:");
|
|
output.print(&format!(
|
|
" {}/requirements.md",
|
|
project.workspace().display()
|
|
));
|
|
return Ok(());
|
|
}
|
|
|
|
// Read requirements
|
|
let requirements = match project.read_requirements()? {
|
|
Some(content) => content,
|
|
None => {
|
|
output.print("❌ Error: Could not read requirements.md");
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
output.print("📋 Requirements loaded from requirements.md");
|
|
output.print("🔄 Starting coach-player feedback loop...");
|
|
|
|
let mut turn = 1;
|
|
let mut coach_feedback = String::new();
|
|
let mut implementation_approved = false;
|
|
|
|
loop {
|
|
output.print(&format!(
|
|
"\n=== TURN {}/{} - PLAYER MODE ===",
|
|
turn, max_turns
|
|
));
|
|
|
|
// Player mode: implement requirements (with coach feedback if available)
|
|
let player_prompt = if coach_feedback.is_empty() {
|
|
format!(
|
|
"You are G3 in implementation mode. Read and implement the following requirements:\n\n{}\n\nImplement this step by step, creating all necessary files and code.",
|
|
requirements
|
|
)
|
|
} else {
|
|
format!(
|
|
"You are G3 in implementation mode. You need to address the coach's feedback and improve your implementation.\n\nORIGINAL REQUIREMENTS:\n{}\n\nCOACH FEEDBACK TO ADDRESS:\n{}\n\nPlease make the necessary improvements to address the coach's feedback while ensuring all original requirements are met.",
|
|
requirements, coach_feedback
|
|
)
|
|
};
|
|
|
|
output.print("🎯 Starting player implementation...");
|
|
|
|
// Execute player task and handle the result properly
|
|
match agent
|
|
.execute_task_with_timing(&player_prompt, None, false, show_prompt, show_code, true)
|
|
.await
|
|
{
|
|
Ok(player_result) => {
|
|
// Display player's implementation result
|
|
output.print("📝 Player implementation completed:");
|
|
output.print_markdown(&player_result);
|
|
}
|
|
Err(e) => {
|
|
output.print(&format!("❌ Player implementation failed: {}", e));
|
|
// Continue to coach review even if player had an error
|
|
}
|
|
}
|
|
|
|
// Give some time for file operations to complete
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
|
|
|
|
// Create a new agent instance for coach mode to ensure fresh context
|
|
let config = g3_config::Config::load(None)?;
|
|
let ui_writer = ConsoleUiWriter::new();
|
|
let mut coach_agent = Agent::new_autonomous(config, ui_writer).await?;
|
|
|
|
// Ensure coach agent is also in the workspace directory
|
|
project.enter_workspace()?;
|
|
|
|
output.print(&format!(
|
|
"\n=== TURN {}/{} - COACH MODE ===",
|
|
turn, max_turns
|
|
));
|
|
|
|
// Coach mode: critique the implementation
|
|
let coach_prompt = format!(
|
|
"You are G3 in coach mode. Your role is to critique and review implementations against requirements.
|
|
|
|
REQUIREMENTS:
|
|
{}
|
|
|
|
IMPLEMENTATION REVIEW:
|
|
Review the current state of the project and provide a concise critique focusing on:
|
|
1. Whether the requirements are correctly implemented
|
|
2. Whether the project compiles successfully
|
|
3. What requirements are missing or incorrect
|
|
4. Specific improvements needed to satisfy requirements
|
|
|
|
IMPORTANT: You MUST use the final_output tool to provide your feedback.
|
|
|
|
If the implementation correctly meets all requirements, call final_output with summary: 'IMPLEMENTATION_APPROVED'
|
|
If improvements are needed, call final_output with specific actionable feedback as the summary.
|
|
|
|
Be thorough but don't be overly critical. APPROVE the implementation if it doesn't have compile errors, glaring omissions and generally fits the bill.",
|
|
requirements
|
|
);
|
|
|
|
output.print("🎓 Starting coach review...");
|
|
let coach_result = coach_agent
|
|
.execute_task_with_timing(&coach_prompt, None, false, show_prompt, show_code, true)
|
|
.await?;
|
|
|
|
output.print("🎓 Coach review completed");
|
|
|
|
// Extract the actual feedback text from the coach result
|
|
// The coach_result might contain timing information at the end (⏱️ ... | 💭 ...)
|
|
// We need to extract just the feedback content
|
|
let coach_feedback_text = if let Some(timing_pos) = coach_result.rfind("\n⏱️") {
|
|
coach_result[..timing_pos].trim().to_string()
|
|
} else {
|
|
coach_result.trim().to_string()
|
|
};
|
|
|
|
// Check if we got empty feedback (this can happen if the coach doesn't call final_output)
|
|
if coach_feedback_text.is_empty() {
|
|
output.print("⚠️ Coach did not provide feedback. This may be a model issue.");
|
|
output.print(" Retrying with a more explicit prompt...");
|
|
|
|
// For now, we'll treat empty feedback as needing improvements
|
|
coach_feedback = "The implementation needs review. Please ensure all requirements are met and the code compiles without errors.".to_string();
|
|
turn += 1;
|
|
continue;
|
|
}
|
|
|
|
output.print(&format!("Coach feedback:\n{}", coach_feedback_text));
|
|
|
|
// Check if coach approved the implementation
|
|
if coach_feedback_text.contains("IMPLEMENTATION_APPROVED") {
|
|
output.print("\n=== SESSION COMPLETED - IMPLEMENTATION APPROVED ===");
|
|
output.print("✅ Coach approved the implementation!");
|
|
implementation_approved = true;
|
|
break;
|
|
}
|
|
|
|
// Check if we've reached max turns
|
|
if turn >= max_turns {
|
|
output.print("\n=== SESSION COMPLETED - MAX TURNS REACHED ===");
|
|
output.print(&format!("⏰ Maximum turns ({}) reached", max_turns));
|
|
break;
|
|
}
|
|
|
|
// Store coach feedback for next iteration
|
|
coach_feedback = coach_feedback_text;
|
|
turn += 1;
|
|
|
|
output.print("🔄 Coach provided feedback for next iteration");
|
|
}
|
|
|
|
if implementation_approved {
|
|
output.print("\n🎉 Autonomous mode completed successfully");
|
|
} else {
|
|
output.print("\n🔄 Autonomous mode completed (max iterations)");
|
|
}
|
|
|
|
Ok(())
|
|
}
|