diff --git a/README.md b/README.md index c3b09aa..0eab884 100644 --- a/README.md +++ b/README.md @@ -132,6 +132,40 @@ G3 is designed for: ## Getting Started +### Default Mode: Accumulative Autonomous + +The default interactive mode now uses **accumulative autonomous mode**, which combines the best of interactive and autonomous workflows: + +```bash +# Simply run g3 in any directory +g3 + +# You'll be prompted to describe what you want to build +# Each input you provide: +# 1. Gets added to accumulated requirements +# 2. Automatically triggers autonomous mode (coach-player loop) +# 3. Implements your requirements iteratively + +# Example session: +requirement> create a simple web server in Python with Flask +# ... autonomous mode runs and implements it ... +requirement> add a /health endpoint that returns JSON +# ... autonomous mode runs again with both requirements ... +``` + +### Other Modes + +```bash +# Single-shot mode (one task, then exit) +g3 "implement a function to calculate fibonacci numbers" + +# Traditional autonomous mode (reads requirements.md) +g3 --autonomous + +# Traditional interactive mode (chat-style, disables accumulative mode) +g3 --accumulative # Note: --accumulative flag disables the new default +``` + ```bash # Build the project cargo build --release diff --git a/crates/g3-cli/src/lib.rs b/crates/g3-cli/src/lib.rs index 355cffc..9ea8acc 100644 --- a/crates/g3-cli/src/lib.rs +++ b/crates/g3-cli/src/lib.rs @@ -174,7 +174,7 @@ mod machine_ui_writer; use machine_ui_writer::MachineUiWriter; use ui_writer_impl::ConsoleUiWriter; -#[derive(Parser)] +#[derive(Parser, Clone)] #[command(name = "g3")] #[command(about = "A modular, composable AI coding agent")] #[command(version)] @@ -241,6 +241,10 @@ pub struct Cli { /// Enable WebDriver browser automation tools #[arg(long)] pub webdriver: bool, + + /// Disable accumulative mode and use traditional interactive mode instead + #[arg(long, help = "Disable accumulative mode (use traditional interactive chat)")] + pub accumulative: bool, } pub async fn run() -> Result<()> { @@ -482,6 +486,13 @@ Output ONLY the markdown content, no explanations or meta-commentary."#, // Execute task, autonomous mode, or start interactive mode based on machine mode if cli.machine { // Machine mode - use MachineUiWriter + if cli.accumulative { + eprintln!("ERROR: --accumulative mode is not compatible with --machine mode"); + eprintln!("Please use either --accumulative or --machine, but not both."); + std::process::exit(1); + } + + let ui_writer = MachineUiWriter::new(); let agent = if cli.autonomous { @@ -493,6 +504,19 @@ Output ONLY the markdown content, no explanations or meta-commentary."#, ) .await? } else { + // NEW DEFAULT: Accumulative mode for interactive sessions + // It runs when: + // 1. No task is provided (not single-shot) + // 2. Not in autonomous mode + // 3. Not explicitly disabled with --accumulative flag + let use_accumulative = cli.task.is_none() && !cli.autonomous && !cli.accumulative; + + if use_accumulative { + // Run accumulative mode and return early + run_accumulative_mode(workspace_dir.clone(), cli.clone(), combined_content.clone()).await?; + return Ok(()); + } + Agent::new_with_readme_and_quiet( config.clone(), ui_writer, @@ -527,7 +551,171 @@ Output ONLY the markdown content, no explanations or meta-commentary."#, run_with_console_mode(agent, cli, project, combined_content).await?; } + + Ok(()) +} +/// Accumulative autonomous mode: accumulates requirements from user input +/// and runs autonomous mode after each input +async fn run_accumulative_mode( + workspace_dir: PathBuf, + cli: Cli, + combined_content: Option, +) -> Result<()> { + let output = SimpleOutput::new(); + + output.print(""); + output.print("šŸŖæ G3 AI Coding Agent - Accumulative Mode"); + output.print(" >> describe what you want, I'll build it iteratively"); + output.print(""); + output.print(&format!("šŸ“ Workspace: {}", workspace_dir.display())); + output.print(""); + output.print("šŸ’” Each input you provide will be added to requirements"); + output.print(" and I'll automatically work on implementing them."); + output.print(""); + output.print(" Type 'exit' or 'quit' to stop, Ctrl+D to finish"); + output.print(""); + + // Initialize rustyline editor with history + let mut rl = DefaultEditor::new()?; + let history_file = dirs::home_dir().map(|mut path| { + path.push(".g3_accumulative_history"); + path + }); + + if let Some(ref history_path) = history_file { + let _ = rl.load_history(history_path); + } + + // Accumulated requirements stored in memory + let mut accumulated_requirements = Vec::new(); + let mut turn_number = 0; + + loop { + output.print(&format!("\n{}", "=".repeat(60))); + if accumulated_requirements.is_empty() { + output.print("šŸ“ What would you like me to build? (describe your requirements)"); + } else { + output.print(&format!("šŸ“ Turn {} - What's next? (add more requirements or refinements)", turn_number + 1)); + } + output.print(&format!("{}", "=".repeat(60))); + + let readline = rl.readline("requirement> "); + match readline { + Ok(line) => { + let input = line.trim().to_string(); + + if input.is_empty() { + continue; + } + + if input == "exit" || input == "quit" { + output.print("\nšŸ‘‹ Goodbye!"); + break; + } + + // Add to history + rl.add_history_entry(&input)?; + + // Add this requirement to accumulated list + turn_number += 1; + accumulated_requirements.push(format!("{}. {}", turn_number, input)); + + // Build the complete requirements document + let requirements_doc = format!( + "# Project Requirements\n\n\ + ## Current Instructions and Requirements:\n\n\ + {}\n\n\ + ## Latest Requirement (Turn {}):\n\n\ + {}", + accumulated_requirements.join("\n"), + turn_number, + input + ); + + output.print(""); + output.print(&format!("šŸ“‹ Current instructions and requirements (Turn {}):", turn_number)); + output.print(&format!(" {}", input)); + output.print(""); + output.print("šŸš€ Starting autonomous implementation..."); + output.print(""); + + // Create a project with the accumulated requirements + let project = Project::new_autonomous_with_requirements( + workspace_dir.clone(), + requirements_doc.clone() + )?; + + // Ensure workspace exists and enter it + project.ensure_workspace_exists()?; + project.enter_workspace()?; + + // Load configuration with CLI overrides + let mut config = Config::load_with_overrides( + cli.config.as_deref(), + cli.provider.clone(), + cli.model.clone(), + )?; + + // Apply macax flag override + if cli.macax { + config.macax.enabled = true; + } + + // Apply webdriver flag override + if cli.webdriver { + config.webdriver.enabled = true; + } + + // Create agent for this autonomous run + let ui_writer = ConsoleUiWriter::new(); + let agent = Agent::new_autonomous_with_readme_and_quiet( + config.clone(), + ui_writer, + combined_content.clone(), + cli.quiet, + ) + .await?; + + // Run autonomous mode with the accumulated requirements + match run_autonomous( + agent, + project, + cli.show_prompt, + cli.show_code, + cli.max_turns, + cli.quiet, + ) + .await + { + Ok(_) => { + output.print(""); + output.print("āœ… Autonomous run completed"); + } + Err(e) => { + output.print(""); + output.print(&format!("āŒ Autonomous run failed: {}", e)); + output.print(" You can provide more requirements to continue."); + } + } + } + Err(ReadlineError::Interrupted) => continue, + Err(ReadlineError::Eof) => { + output.print("\nšŸ‘‹ Goodbye!"); + 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); + } + Ok(()) } diff --git a/docs/ACCUMULATIVE_MODE.md b/docs/ACCUMULATIVE_MODE.md new file mode 100644 index 0000000..d662ef6 --- /dev/null +++ b/docs/ACCUMULATIVE_MODE.md @@ -0,0 +1,386 @@ +# Accumulative Autonomous Mode + +## Overview + +Accumulative Autonomous Mode is the **new default interactive mode** for G3. It combines the ease of interactive chat with the power of autonomous implementation, allowing you to build projects iteratively by describing what you want, one requirement at a time. + +## How It Works + +### The Flow + +1. **Start G3** in any directory (no arguments needed) +2. **Describe** what you want to build +3. **G3 automatically**: + - Adds your input to accumulated requirements + - Runs autonomous mode (coach-player feedback loop) + - Implements your requirements with quality checks +4. **Continue** adding more requirements or refinements +5. **Repeat** until your project is complete + +### Example Session + +```bash +$ cd ~/projects/my-new-app +$ g3 + +šŸŖæ G3 AI Coding Agent - Accumulative Mode + >> describe what you want, I'll build it iteratively + +šŸ“ Workspace: /Users/you/projects/my-new-app + +šŸ’” Each input you provide will be added to requirements + and I'll automatically work on implementing them. + + Type 'exit' or 'quit' to stop, Ctrl+D to finish + +============================================================ +šŸ“ What would you like me to build? (describe your requirements) +============================================================ +requirement> create a simple web server in Python with Flask that serves a homepage + +šŸ“‹ Current instructions and requirements (Turn 1): + create a simple web server in Python with Flask that serves a homepage + +šŸš€ Starting autonomous implementation... + +šŸ¤– G3 AI Coding Agent - Autonomous Mode +šŸ“ Using workspace: /Users/you/projects/my-new-app +šŸ“‹ Requirements loaded from --requirements flag +šŸ”„ Starting coach-player feedback loop... +šŸ“‚ No existing implementation files detected +šŸŽÆ Starting with player implementation + +=== TURN 1/5 - PLAYER MODE === +šŸŽÆ Starting player implementation... +šŸ“‹ Player starting initial implementation (no prior coach feedback) + +[Player creates files, writes code...] + +=== TURN 1/5 - COACH MODE === +šŸŽ“ Starting coach review... +šŸŽ“ Coach review completed +Coach feedback: +The Flask server is implemented correctly with a homepage route. +The code follows best practices and meets the requirements. +IMPLEMENTATION_APPROVED + +=== SESSION COMPLETED - IMPLEMENTATION APPROVED === +āœ… Coach approved the implementation! + +============================================================ +šŸ“Š AUTONOMOUS MODE SESSION REPORT +============================================================ +ā±ļø Total Duration: 12.34s +šŸ”„ Turns Taken: 1/5 +šŸ“ Final Status: āœ… APPROVED +... +============================================================ + +āœ… Autonomous run completed + +============================================================ +šŸ“ Turn 2 - What's next? (add more requirements or refinements) +============================================================ +requirement> add a /api/users endpoint that returns a list of users as JSON + +šŸ“‹ Current instructions and requirements (Turn 2): + add a /api/users endpoint that returns a list of users as JSON + +šŸš€ Starting autonomous implementation... + +[Autonomous mode runs again with BOTH requirements...] + +============================================================ +šŸ“ Turn 3 - What's next? (add more requirements or refinements) +============================================================ +requirement> exit + +šŸ‘‹ Goodbye! +``` + +## Key Features + +### 1. Requirement Accumulation + +Each input you provide is: +- **Numbered sequentially** (1, 2, 3, ...) +- **Stored in memory** for the session +- **Included in all subsequent runs** + +This means the agent always has the full context of what you've asked for. + +### 2. Automatic Requirements Document + +G3 automatically generates a structured requirements document: + +```markdown +# Project Requirements + +## Current Instructions and Requirements: + +1. create a simple web server in Python with Flask that serves a homepage +2. add a /api/users endpoint that returns a list of users as JSON +3. add error handling for 404 and 500 errors + +## Latest Requirement (Turn 3): + +add error handling for 404 and 500 errors +``` + +This document is passed to autonomous mode, ensuring the agent: +- Knows all previous requirements +- Focuses on the latest addition +- Maintains consistency across iterations + +### 3. Full Autonomous Quality + +Each requirement triggers a complete autonomous run with: +- **Coach-Player Feedback Loop**: Quality assurance built-in +- **Multiple Turns**: Up to 5 iterations per requirement (configurable with `--max-turns`) +- **Compilation Checks**: Ensures code actually works +- **Testing**: Coach can run tests to verify functionality + +### 4. Error Recovery + +If an autonomous run fails: +- You're notified of the error +- You can provide additional requirements to fix issues +- The session continues (doesn't crash) + +### 5. Workspace Management + +- Uses **current directory** as workspace +- All files created in current directory +- No need to specify workspace path +- Works with existing projects or empty directories + +## Command-Line Options + +### Default (Accumulative Mode) + +```bash +g3 +``` + +Starts accumulative autonomous mode in the current directory. + +### With Options + +```bash +# Use a specific workspace +g3 --workspace ~/projects/my-app + +# Limit autonomous turns per requirement +g3 --max-turns 3 + +# Enable macOS Accessibility tools +g3 --macax + +# Enable WebDriver browser automation +g3 --webdriver + +# Use a specific provider/model +g3 --provider anthropic --model claude-3-5-sonnet-20241022 + +# Show prompts and code during execution +g3 --show-prompt --show-code + +# Disable log files +g3 --quiet +``` + +### Disable Accumulative Mode + +To use the traditional interactive chat mode: + +```bash +g3 --accumulative +``` + +This gives you the old behavior where you chat with the agent without automatic autonomous runs. + +## Use Cases + +### 1. Rapid Prototyping + +```bash +requirement> create a REST API for a todo app +requirement> add SQLite database storage +requirement> add authentication with JWT +requirement> add rate limiting +``` + +### 2. Iterative Refinement + +```bash +requirement> create a data visualization dashboard +requirement> make the charts interactive +requirement> add dark mode support +requirement> optimize for mobile devices +``` + +### 3. Bug Fixing + +```bash +requirement> fix the login form validation +requirement> handle edge case when username is empty +requirement> add better error messages +``` + +### 4. Feature Addition + +```bash +requirement> add export to CSV functionality +requirement> add email notifications +requirement> add admin dashboard +``` + +## Tips and Best Practices + +### 1. Start Simple + +Begin with a basic requirement, let it be implemented, then add complexity: + +```bash +āœ… Good: +requirement> create a basic Flask web server +requirement> add a homepage with a form +requirement> add form validation + +āŒ Too Complex: +requirement> create a full-stack web app with authentication, database, API, and frontend +``` + +### 2. Be Specific + +The more specific you are, the better the results: + +```bash +āœ… Good: +requirement> add a /api/users endpoint that returns JSON with id, name, and email fields + +āŒ Vague: +requirement> add users +``` + +### 3. One Thing at a Time + +Focus each requirement on a single feature or fix: + +```bash +āœ… Good: +requirement> add error handling for database connections +requirement> add logging for all API requests + +āŒ Multiple Things: +requirement> add error handling and logging and monitoring and alerts +``` + +### 4. Review Between Turns + +After each autonomous run completes: +- Check the generated files +- Test the functionality +- Decide what to add or fix next + +### 5. Use Exit Commands + +When done: +- Type `exit` or `quit` +- Press `Ctrl+D` (EOF) +- Press `Ctrl+C` to cancel current input + +## Comparison with Other Modes + +| Feature | Accumulative (Default) | Traditional Interactive | Autonomous | Single-Shot | +|---------|----------------------|------------------------|------------|-------------| +| **Command** | `g3` | `g3 --accumulative` | `g3 --autonomous` | `g3 "task"` | +| **Input Style** | Iterative prompts | Chat messages | requirements.md file | Command-line arg | +| **Auto-Autonomous** | āœ… Yes | āŒ No | āœ… Yes | āŒ No | +| **Coach-Player Loop** | āœ… Yes | āŒ No | āœ… Yes | āŒ No | +| **Accumulates Requirements** | āœ… Yes | āŒ No | āŒ No | āŒ No | +| **Multiple Iterations** | āœ… Yes | āœ… Yes | āœ… Yes | āŒ No | +| **Best For** | Iterative development | Quick questions | Pre-planned projects | One-off tasks | + +## Technical Details + +### Requirements Storage + +- Stored in memory (not persisted to disk) +- Numbered sequentially starting from 1 +- Formatted as markdown list +- Passed to autonomous mode as `--requirements` override + +### History + +- Saved to `~/.g3_accumulative_history` +- Separate from traditional interactive history +- Persists across sessions +- Uses rustyline for readline support + +### Workspace + +- Defaults to current directory +- Can be overridden with `--workspace` +- All files created in workspace +- Logs saved to `workspace/logs/` + +### Autonomous Execution + +- Full coach-player feedback loop +- Configurable max turns (default: 5) +- Respects all CLI flags (--macax, --webdriver, etc.) +- Error handling allows continuation + +## Troubleshooting + +### "No requirements provided" + +This shouldn't happen in accumulative mode, but if it does: +- Check that you entered a requirement +- Ensure the requirement isn't empty +- Try restarting G3 + +### "Autonomous run failed" + +If an autonomous run fails: +- Read the error message +- Provide a new requirement to fix the issue +- Or type `exit` and investigate manually + +### "Context window full" + +If you hit token limits: +- The agent will auto-summarize +- Or you can start a new session +- Consider using `--max-turns` to limit iterations + +### "Coach never approves" + +If the coach keeps rejecting: +- Check the coach feedback for specific issues +- Provide more specific requirements +- Consider increasing `--max-turns` + +## Future Enhancements + +Planned improvements: + +1. **Persistence**: Save accumulated requirements to disk +2. **Editing**: Edit or remove previous requirements +3. **Branching**: Try different approaches +4. **Templates**: Pre-defined requirement sets +5. **Review**: Show all accumulated requirements +6. **Export**: Save to requirements.md +7. **Undo**: Remove last requirement +8. **Replay**: Re-run with same requirements + +## Feedback + +This is a new feature! Please provide feedback: +- What works well? +- What's confusing? +- What features would you like? +- Any bugs or issues? + +Open an issue on GitHub or contribute improvements!