integrate 'Morph Fast Apply' and ripgrep; limit recursion loop

Author: alexylon

README.md

@@ -6,12 +6,22 @@ An interactive AI coding assistant powered by Claude that can write code, edit f
 
 - **Interactive REPL** - Multi-turn conversations with Claude
 - **File Operations** - Read, write, list, and create files/directories (sandboxed to current directory)
+- **Ultra-Fast Editing** - Optional Morph Apply integration (10,500+ tokens/sec, 96-98% accuracy)
+- **Code Search** - Fast regex-based code search using ripgrep (optional)
 - **Web Search** - Real-time information via DuckDuckGo
 - **Secure** - All file operations restricted to workspace, prevents directory traversal
 
 ## Installation
 
-**Requirements:** Rust 1.70+, Anthropic API key ([get one](https://console.anthropic.com/))
+**Requirements:** 
+
+- Rust 1.70+
+- Anthropic API key ([get one](https://console.anthropic.com/))
+
+**Optional:** 
+
+- `ripgrep` for code search ([install guide](https://github.com/BurntSushi/ripgrep#installation))
+- Morph API key ([get one](https://morphllm.com/))
 
 ```bash
 git clone https://github.com/alexylon/sofos-code.git
@@ -21,15 +31,28 @@ cargo install --path .
 
 ## Usage
 
+### Set API key
+
 ```bash
-# Set API key
 export ANTHROPIC_API_KEY='your-api-key'
+```
+
+### Enable Ultra-Fast Editing (Optional). When enabled, Claude can use the `edit_file_fast` tool for lightning-fast, accurate code modifications.
+
+```bash
+export MORPH_API_KEY='your-morph-key'
+```
 
-# Start interactive mode
+### Start interactive mode
+
+```bash
 sofos
+```
 
-# One-shot mode
-sofos --prompt "Create a hello world Python script"
+### One-shot mode
+
+```bash
+sofos --prompt "Create a hello world Rust program"
 ```
 
 ### Commands
@@ -41,21 +64,28 @@ sofos --prompt "Create a hello world Python script"
 ### Options
 
 ```
---api-key <KEY>     API key (overrides env var)
--p, --prompt <TEXT> One-shot mode
---model <MODEL>     Claude model (default: claude-sonnet-4-5)
---max-tokens <N>    Max response tokens (default: 4096)
--v, --verbose       Verbose logging
+--api-key <KEY>         Anthropic API key (overrides ANTHROPIC_API_KEY)
+--morph-api-key <KEY>   Morph API key (overrides MORPH_API_KEY)
+-p, --prompt <TEXT>     One-shot mode
+--model <MODEL>         Claude model (default: claude-sonnet-4-5)
+--morph-model <MODEL>   Morph model (default: morph-v3-fast)
+--max-tokens <N>        Max response tokens (default: 4096)
+-v, --verbose           Verbose logging
 ```
 
 ## Available Tools
 
 Claude can automatically use these tools:
 
+**File Operations:**
 - `read_file` - Read file contents
 - `write_file` - Create or overwrite files
+- `edit_file_fast` - Ultra-fast code editing (requires MORPH_API_KEY)
 - `list_directory` - List directory contents
 - `create_directory` - Create directories
+
+**Code & Search:**
+- `search_code` - Fast regex-based code search (requires `ripgrep`)
 - `web_search` - Search the internet
 
 ## Security
@@ -94,9 +124,18 @@ RUST_LOG=debug sofos
 
 MIT License
 
+## Morph Integration Status
+
+Sofos integrates with Morph's APIs for enhanced performance:
+
+✅ **Morph Apply** - Ultra-fast code editing (10,500+ tokens/sec, 96-98% accuracy)
+- Direct REST API integration
+- Works with `edit_file_fast` tool
+- Optional - enable with `MORPH_API_KEY`
+
 ## Acknowledgments
 
-Built with Rust and powered by Anthropic's Claude. Inspired by Aider and similar tools.
+Built with Rust and powered by Anthropic's Claude. Morph Apply integration for fast edits. Inspired by Aider and similar tools.
 
 ---
 

src/api/mod.rs

@@ -1,5 +1,7 @@
 pub mod client;
+pub mod morph;
 pub mod types;
 
 pub use client::AnthropicClient;
+pub use morph::MorphClient;
 pub use types::*;

src/api/morph.rs

@@ -0,0 +1,122 @@
+use crate::error::{Result, SofosError};
+use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
+use serde::{Deserialize, Serialize};
+
+const MORPH_BASE_URL: &str = "https://api.morphllm.com/v1";
+
+#[derive(Debug, Serialize)]
+struct MorphMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Debug, Serialize)]
+struct MorphRequest {
+    model: String,
+    messages: Vec<MorphMessage>,
+}
+
+#[derive(Debug, Deserialize)]
+struct MorphResponse {
+    choices: Vec<MorphChoice>,
+}
+
+#[derive(Debug, Deserialize)]
+struct MorphChoice {
+    message: MorphMessageResponse,
+}
+
+#[derive(Debug, Deserialize)]
+struct MorphMessageResponse {
+    content: String,
+}
+
+pub struct MorphClient {
+    client: reqwest::Client,
+    model: String,
+}
+
+impl MorphClient {
+    pub fn new(api_key: String, model: Option<String>) -> Result<Self> {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "Authorization",
+            HeaderValue::from_str(&format!("Bearer {}", api_key))
+                .map_err(|e| SofosError::Config(format!("Invalid Morph API key: {}", e)))?,
+        );
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+
+        let client = reqwest::Client::builder()
+            .default_headers(headers)
+            .build()
+            .map_err(|e| SofosError::Config(format!("Failed to create HTTP client: {}", e)))?;
+
+        Ok(Self {
+            client,
+            model: model.unwrap_or_else(|| "morph-v3-fast".to_string()),
+        })
+    }
+
+    /// Apply code edits using Morph's fast apply API
+    ///
+    /// Format requirements:
+    /// - instruction: Brief first-person description of changes
+    /// - original_code: Complete original code
+    /// - code_edit: Updated code with "// ... existing code ..." markers for unchanged sections
+    pub async fn apply_edit(
+        &self,
+        instruction: &str,
+        original_code: &str,
+        code_edit: &str,
+    ) -> Result<String> {
+        let content = format!(
+            "<instruction>{}</instruction>\n<code>{}</code>\n<update>{}</update>",
+            instruction, original_code, code_edit
+        );
+
+        let request = MorphRequest {
+            model: self.model.clone(),
+            messages: vec![MorphMessage {
+                role: "user".to_string(),
+                content,
+            }],
+        };
+
+        let url = format!("{}/chat/completions", MORPH_BASE_URL);
+
+        let response = self
+            .client
+            .post(&url)
+            .json(&request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response.text().await.unwrap_or_default();
+            return Err(SofosError::Api(format!(
+                "Morph API request failed with status {}: {}",
+                status, error_text
+            )));
+        }
+
+        let result: MorphResponse = response.json().await?;
+
+        Ok(result
+            .choices
+            .first()
+            .map(|c| c.message.content.clone())
+            .ok_or_else(|| SofosError::Api("No response from Morph API".to_string()))?)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_morph_client_creation() {
+        let client = MorphClient::new("test-key".to_string(), None);
+        assert!(client.is_ok());
+    }
+}

src/cli.rs

@@ -11,13 +11,19 @@ pub struct Cli {
     #[arg(long, env = "ANTHROPIC_API_KEY")]
     pub api_key: Option<String>,
 
+    #[arg(long, env = "MORPH_API_KEY")]
+    pub morph_api_key: Option<String>,
+
     /// Initial prompt to send (if not provided, starts interactive REPL)
     #[arg(short, long)]
     pub prompt: Option<String>,
 
     #[arg(long, default_value = "claude-sonnet-4-5")]
     pub model: String,
 
+    #[arg(long, default_value = "morph-v3-fast")]
+    pub morph_model: String,
+
     #[arg(long, default_value = "4096")]
     pub max_tokens: u32,
 

src/conversation.rs

@@ -8,27 +8,49 @@ pub struct ConversationHistory {
 
 impl ConversationHistory {
     pub fn new() -> Self {
-        let system_prompt = r#"You are Sofos, an AI coding assistant. You have access to tools that allow you to:
-1. Read files in the current project directory
-2. Write/create files in the current project directory
-3. List directory contents
-4. Create directories
-5. Search the web for information
+        Self::with_features(false, false)
+    }
+
+    pub fn with_features(has_morph: bool, has_code_search: bool) -> Self {
+        let mut features = vec![
+            "1. Read files in the current project directory",
+            "2. Write/create files in the current project directory",
+            "3. List directory contents",
+            "4. Create directories",
+            "5. Search the web for information",
+        ];
+
+        if has_code_search {
+            features.push("6. Search code using ripgrep");
+        }
+
+        let edit_instruction = if has_morph {
+            "- When creating new files, use the write_file tool\n- When editing existing files, ALWAYS use the edit_file_fast tool (ultra-fast, 10,500+ tokens/sec)"
+        } else {
+            "- When creating or editing code, use the write_file tool"
+        };
+
+        let system_prompt = format!(
+            r#"You are Sofos, an AI coding assistant. You have access to tools that allow you to:
+{}
 
 IMPORTANT: All file operations are restricted to the current working directory for security. You cannot access files outside this directory.
 
 When helping users:
 - Be concise and practical
 - Use your tools to read files before suggesting changes
-- When creating or editing code, use the write_file tool
+{}
 - Search the web when you need current information or documentation
 - Explain your reasoning when using tools
 
-Your goal is to help users with coding tasks efficiently and accurately."#;
+Your goal is to help users with coding tasks efficiently and accurately."#,
+            features.join("\n"),
+            edit_instruction
+        );
 
         Self {
             messages: Vec::new(),
-            system_prompt: system_prompt.to_string(),
+            system_prompt,
         }
     }
 

src/main.rs

@@ -5,6 +5,7 @@ mod error;
 mod repl;
 mod tools;
 
+use api::MorphClient;
 use clap::Parser;
 use cli::Cli;
 use colored::Colorize;
@@ -43,9 +44,23 @@ fn main() -> Result<()> {
         "Workspace:".bright_cyan(),
         workspace.display().to_string().dimmed()
     );
+
+    let morph_client = cli.morph_api_key.as_ref().and_then(|key| {
+        match MorphClient::new(key.clone(), Some(cli.morph_model.clone())) {
+            Ok(client) => {
+                println!("{}", "Morph Fast Apply: Enabled".bright_green());
+                Some(client)
+            }
+            Err(e) => {
+                eprintln!("{} Failed to initialize Morph client: {}", "Warning:".bright_yellow(), e);
+                None
+            }
+        }
+    });
+
     println!();
 
-    let mut repl = Repl::new(api_key, cli.model, cli.max_tokens, workspace)?;
+    let mut repl = Repl::new(api_key, cli.model, cli.max_tokens, workspace, morph_client)?;
 
     if let Some(prompt) = cli.prompt {
         repl.process_single_prompt(&prompt)?;