feat: implement planning agent with interactive conversation

Co-Authored-By: Claude Sonnet 4.5 <[e-mail]>

Cargo.lock

···
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
 name = "displaydoc"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
 
 [[package]]
+name = "libredox"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
+dependencies = [
+ "bitflags",
+ "libc",
+]
+
+[[package]]
 name = "linux-raw-sys"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
 name = "parking_lot"
 version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror",
+]
+
+[[package]]
 name = "regex"
 version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "anyhow",
  "async-trait",
  "clap",
+ "dirs",
  "env_logger",
  "log",
  "reqwest",
···
 ]
 
 [[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "tinystr"
 version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
···
 
 [[package]]
 name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
···
 
 [[package]]
 name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
···
 
 [[package]]
 name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
···
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
···
 
 [[package]]
 name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
···
 
 [[package]]
 name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
···
 
 [[package]]
 name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
···
 version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"

Cargo.toml

···
 clap = { version = "4.5", features = ["derive"] }
 log = "0.4"
 env_logger = "0.11"
+dirs = "5.0"
 
 [dev-dependencies]
 tempfile = "3.15"

src/lib.rs

···
 pub mod config;
 pub mod llm;
+pub mod planning;
+pub mod spec;
 pub mod tools;
-pub mod spec;

src/main.rs

···
 pub mod config;
 pub mod llm;
+pub mod planning;
 pub mod spec;
 pub mod tools;
 
 use clap::{Parser, Subcommand};
+use std::path::PathBuf;
 
 #[derive(Parser)]
 #[command(name = "rustagent")]
···
     },
 }
 
+/// Find config file in standard locations
+fn find_config_path() -> anyhow::Result<PathBuf> {
+    // Try current directory
+    let local_config = PathBuf::from("rustagent.toml");
+    if local_config.exists() {
+        return Ok(local_config);
+    }
+
+    // Try XDG config directory
+    if let Some(config_dir) = dirs::config_dir() {
+        let xdg_config = config_dir.join("rustagent").join("config.toml");
+        if xdg_config.exists() {
+            return Ok(xdg_config);
+        }
+    }
+
+    // Try home directory
+    if let Some(home_dir) = dirs::home_dir() {
+        let home_config = home_dir.join(".rustagent").join("config.toml");
+        if home_config.exists() {
+            return Ok(home_config);
+        }
+    }
+
+    anyhow::bail!("Config file not found. Please create rustagent.toml in current directory or ~/.rustagent/config.toml")
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     env_logger::init();
···
             // TODO: Implement initialization logic
         }
         Commands::Plan { spec_dir } => {
-            let dir = spec_dir.clone().unwrap_or_else(|| ".".to_string());
-            println!("Creating plan from spec directory: {}", dir);
-            // TODO: Implement plan creation logic
+            // Load config from standard locations
+            let config_path = find_config_path()?;
+            let config = config::Config::load(&config_path)?;
+
+            // Use provided spec_dir or default from config
+            let dir = spec_dir
+                .clone()
+                .unwrap_or_else(|| config.rustagent.spec_dir.clone());
+
+            // Create and run planning agent
+            let mut agent = planning::PlanningAgent::new(config, dir);
+            agent.run().await?;
         }
         Commands::Run { spec_file, max_iterations } => {
             println!("Running agent with spec: {}", spec_file);

src/planning/mod.rs

···
+use crate::config::{Config, LlmProvider};
+use crate::llm::{LlmClient, Message, ResponseContent, Role};
+use crate::llm::anthropic::AnthropicClient;
+use crate::tools::{ToolRegistry, file::{ReadFileTool, WriteFileTool, ListFilesTool}, shell::RunCommandTool};
+use std::io::{self, Write};
+
+/// Planning agent for interactive spec creation
+pub struct PlanningAgent {
+    client: Box<dyn LlmClient>,
+    registry: ToolRegistry,
+    pub spec_dir: String,
+    conversation: Vec<Message>,
+}
+
+impl PlanningAgent {
+    /// Create a new planning agent with the given config
+    pub fn new(config: Config, spec_dir: String) -> Self {
+        // Create LLM client based on provider
+        let client: Box<dyn LlmClient> = match config.llm.provider {
+            LlmProvider::Anthropic => {
+                let api_key = config
+                    .anthropic
+                    .expect("Anthropic config required for Anthropic provider")
+                    .api_key;
+                Box::new(AnthropicClient::new(api_key))
+            }
+            _ => panic!("Unsupported LLM provider"),
+        };
+
+        // Create and populate tool registry
+        let mut registry = ToolRegistry::new();
+        registry.register(Box::new(ReadFileTool));
+        registry.register(Box::new(WriteFileTool));
+        registry.register(Box::new(ListFilesTool));
+        registry.register(Box::new(RunCommandTool));
+
+        // Initialize conversation with system message
+        let system_message = Message {
+            role: Role::System,
+            content: PLANNING_SYSTEM_PROMPT.to_string(),
+        };
+
+        Self {
+            client,
+            registry,
+            spec_dir,
+            conversation: vec![system_message],
+        }
+    }
+
+    /// Run the interactive planning loop
+    pub async fn run(&mut self) -> anyhow::Result<()> {
+        println!("Planning Agent - Interactive Mode");
+        println!("Type your requirements and I'll help you create a detailed spec.");
+        println!("Type 'done' when finished or 'exit' to quit.\n");
+
+        loop {
+            // Get user input
+            print!("You: ");
+            io::stdout().flush()?;
+
+            let mut input = String::new();
+            io::stdin().read_line(&mut input)?;
+            let input = input.trim();
+
+            if input == "exit" {
+                println!("Exiting planning mode.");
+                break;
+            }
+
+            if input == "done" {
+                println!("Planning complete. Spec saved to {}", self.spec_dir);
+                break;
+            }
+
+            if input.is_empty() {
+                continue;
+            }
+
+            // Add user message to conversation
+            self.conversation.push(Message {
+                role: Role::User,
+                content: input.to_string(),
+            });
+
+            // Process the conversation turn
+            match self.process_turn().await {
+                Ok(should_continue) => {
+                    if !should_continue {
+                        break;
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Error: {}", e);
+                    // Remove the failed user message
+                    self.conversation.pop();
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Process a single conversation turn
+    async fn process_turn(&mut self) -> anyhow::Result<bool> {
+        loop {
+            // Get tool definitions
+            let tools = self.registry.definitions();
+
+            // Call LLM
+            let response = self
+                .client
+                .chat(self.conversation.clone(), &tools)
+                .await
+                .map_err(|e| anyhow::anyhow!("LLM error: {}", e))?;
+
+            match response.content {
+                ResponseContent::Text(text) => {
+                    // Add assistant response to conversation
+                    self.conversation.push(Message {
+                        role: Role::Assistant,
+                        content: text.clone(),
+                    });
+
+                    // Print assistant response
+                    println!("\nAssistant: {}\n", text);
+
+                    // Check for completion
+                    if let Some(stop_reason) = &response.stop_reason {
+                        if stop_reason == "end_turn" {
+                            return Ok(true);
+                        }
+                    }
+
+                    return Ok(true);
+                }
+                ResponseContent::ToolCalls(tool_calls) => {
+                    // Execute each tool call
+                    for tool_call in &tool_calls {
+                        println!("\n[Executing tool: {}]", tool_call.name);
+
+                        // Get the tool from registry
+                        let tool = self
+                            .registry
+                            .get(&tool_call.name)
+                            .ok_or_else(|| anyhow::anyhow!("Tool not found: {}", tool_call.name))?;
+
+                        // Execute the tool
+                        let result = tool.execute(tool_call.parameters.clone()).await;
+
+                        let output = match result {
+                            Ok(output) => {
+                                println!("[Tool result: {} bytes]", output.len());
+                                output
+                            }
+                            Err(e) => {
+                                println!("[Tool error: {}]", e);
+                                format!("Error: {}", e)
+                            }
+                        };
+
+                        // Add tool result to conversation
+                        self.conversation.push(Message {
+                            role: Role::User,
+                            content: format!(
+                                "Tool result for {}:\n{}",
+                                tool_call.name, output
+                            ),
+                        });
+                    }
+
+                    // Continue the loop to get the next LLM response
+                }
+            }
+        }
+    }
+}
+
+const PLANNING_SYSTEM_PROMPT: &str = r#"You are a planning agent that helps users create detailed specifications for software development tasks.
+
+Your role is to:
+1. Ask clarifying questions to understand the user's requirements
+2. Break down complex tasks into smaller, manageable subtasks
+3. Define clear acceptance criteria for each task
+4. Create a structured specification file in JSON format
+
+When the user provides their requirements, you should:
+- Ask about technical constraints, dependencies, and environment
+- Identify risks and edge cases
+- Suggest best practices and design patterns
+- Help define test criteria
+
+Use the available tools to:
+- read_file: Read existing files to understand the codebase
+- write_file: Create the specification file
+- list_files: Explore the project structure
+- run_command: Run commands to gather information about the environment
+
+When you have enough information, create a spec.json file with this structure:
+{
+  "name": "project-name",
+  "description": "Brief description of the project",
+  "branch_name": "feature/branch-name",
+  "created_at": "2024-01-01T00:00:00Z",
+  "tasks": [
+    {
+      "id": "task-1",
+      "title": "Task title",
+      "description": "Detailed task description",
+      "acceptance_criteria": [
+        "Criterion 1",
+        "Criterion 2"
+      ],
+      "status": "pending"
+    }
+  ],
+  "learnings": []
+}
+
+Be thorough but efficient. Ask questions one at a time to avoid overwhelming the user.
+"#;

tests/planning_test.rs

···
+use rustagent::planning::PlanningAgent;
+use rustagent::config::Config;
+use tempfile::TempDir;
+use std::fs;
+
+#[tokio::test]
+async fn test_planning_agent_creation() {
+    let temp = TempDir::new().unwrap();
+    let config_path = temp.path().join("config.toml");
+
+    fs::write(&config_path, r#"
+[llm]
+provider = "anthropic"
+model = "claude-sonnet-4-20250514"
+
+[anthropic]
+api_key = "test-key"
+
+[rustagent]
+spec_dir = "specs"
+"#).unwrap();
+
+    let config = Config::load(&config_path).unwrap();
+    let agent = PlanningAgent::new(config, temp.path().to_str().unwrap().to_string());
+
+    assert!(agent.spec_dir.ends_with(temp.path().to_str().unwrap()));
+}