automagik-forge 0.1.13 → 0.1.14

package/backend/src/executors/mod.rs

@@ -1,23 +0,0 @@
-pub mod amp;
-pub mod ccr;
-pub mod charm_opencode;
-pub mod claude;
-pub mod cleanup_script;
-pub mod dev_server;
-pub mod echo;
-pub mod gemini;
-pub mod opencode_ai;
-pub mod setup_script;
-pub mod sst_opencode;
-
-pub use amp::AmpExecutor;
-pub use ccr::CCRExecutor;
-pub use charm_opencode::CharmOpencodeExecutor;
-pub use claude::ClaudeExecutor;
-pub use cleanup_script::CleanupScriptExecutor;
-pub use dev_server::DevServerExecutor;
-pub use echo::EchoExecutor;
-pub use gemini::GeminiExecutor;
-pub use opencode_ai::OpencodeAiExecutor;
-pub use setup_script::SetupScriptExecutor;
-pub use sst_opencode::SstOpencodeExecutor;

package/backend/src/executors/opencode_ai.rs

@@ -1,113 +0,0 @@
-use async_trait::async_trait;
-use command_group::{AsyncCommandGroup, AsyncGroupChild};
-use uuid::Uuid;
-
-use crate::{
-    executor::{Executor, ExecutorError},
-    models::task::Task,
-    utils::shell::get_shell_command,
-};
-
-/// An executor that uses OpenCode to process tasks
-pub struct OpencodeAiExecutor;
-
-#[async_trait]
-impl Executor for OpencodeAiExecutor {
-    async fn spawn(
-        &self,
-        pool: &sqlx::SqlitePool,
-        task_id: Uuid,
-        worktree_path: &str,
-    ) -> Result<AsyncGroupChild, ExecutorError> {
-        // Get the task to fetch its description
-        let task = Task::find_by_id(pool, task_id)
-            .await?
-            .ok_or(ExecutorError::TaskNotFound)?;
-
-        use std::process::Stdio;
-
-        use tokio::process::Command;
-
-        let prompt = if let Some(task_description) = task.description {
-            format!(
-                r#"project_id: {}
-            
-Task title: {}
-Task description: {}"#,
-                task.project_id, task.title, task_description
-            )
-        } else {
-            format!(
-                r#"project_id: {}
-            
-Task title: {}"#,
-                task.project_id, task.title
-            )
-        };
-
-        // Use shell command for cross-platform compatibility
-        let (shell_cmd, shell_arg) = get_shell_command();
-        let opencode_command = format!(
-            "opencode -p \"{}\" --output-format=json",
-            prompt.replace('"', "\\\"")
-        );
-
-        let mut command = Command::new(shell_cmd);
-        command
-            .kill_on_drop(true)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .current_dir(worktree_path)
-            .arg(shell_arg)
-            .arg(opencode_command);
-
-        let child = command
-            .group_spawn() // Create new process group so we can kill entire tree
-            .map_err(|e| {
-                crate::executor::SpawnContext::from_command(&command, "OpenCode AI")
-                    .with_task(task_id, Some(task.title.clone()))
-                    .with_context("OpenCode AI CLI execution for new task")
-                    .spawn_error(e)
-            })?;
-
-        Ok(child)
-    }
-
-    async fn spawn_followup(
-        &self,
-        _pool: &sqlx::SqlitePool,
-        _task_id: Uuid,
-        _session_id: &str,
-        prompt: &str,
-        worktree_path: &str,
-    ) -> Result<AsyncGroupChild, ExecutorError> {
-        use std::process::Stdio;
-
-        use tokio::process::Command;
-
-        // CharmOpencode doesn't support session-based followup, so we ignore session_id
-        // and just run with the new prompt
-        let (shell_cmd, shell_arg) = get_shell_command();
-        let opencode_command = format!(
-            "opencode -p \"{}\" --output-format=json",
-            prompt.replace('"', "\\\"")
-        );
-
-        let mut command = Command::new(shell_cmd);
-        command
-            .kill_on_drop(true)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .current_dir(worktree_path)
-            .arg(shell_arg)
-            .arg(&opencode_command);
-
-        let child = command.group_spawn().map_err(|e| {
-            crate::executor::SpawnContext::from_command(&command, "OpenCode AI")
-                .with_context("OpenCode AI CLI followup execution")
-                .spawn_error(e)
-        })?;
-
-        Ok(child)
-    }
-}

package/backend/src/executors/setup_script.rs

@@ -1,130 +0,0 @@
-use async_trait::async_trait;
-use command_group::{AsyncCommandGroup, AsyncGroupChild};
-use tokio::process::Command;
-use uuid::Uuid;
-
-use crate::{
-    executor::{Executor, ExecutorError},
-    models::{project::Project, task::Task},
-    utils::shell::get_shell_command,
-};
-
-/// Executor for running project setup scripts
-pub struct SetupScriptExecutor {
-    pub script: String,
-}
-
-impl SetupScriptExecutor {
-    pub fn new(script: String) -> Self {
-        Self { script }
-    }
-}
-
-#[async_trait]
-impl Executor for SetupScriptExecutor {
-    async fn spawn(
-        &self,
-        pool: &sqlx::SqlitePool,
-        task_id: Uuid,
-        worktree_path: &str,
-    ) -> Result<AsyncGroupChild, ExecutorError> {
-        // Validate the task and project exist
-        let task = Task::find_by_id(pool, task_id)
-            .await?
-            .ok_or(ExecutorError::TaskNotFound)?;
-
-        let _project = Project::find_by_id(pool, task.project_id)
-            .await?
-            .ok_or(ExecutorError::TaskNotFound)?; // Reuse TaskNotFound for simplicity
-
-        let (shell_cmd, shell_arg) = get_shell_command();
-        let mut command = Command::new(shell_cmd);
-        command
-            .kill_on_drop(true)
-            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::piped())
-            .arg(shell_arg)
-            .arg(&self.script)
-            .current_dir(worktree_path);
-
-        let child = command.group_spawn().map_err(|e| {
-            crate::executor::SpawnContext::from_command(&command, "SetupScript")
-                .with_task(task_id, Some(task.title.clone()))
-                .with_context("Setup script execution")
-                .spawn_error(e)
-        })?;
-
-        Ok(child)
-    }
-
-    /// Normalize setup script logs into a readable format
-    fn normalize_logs(
-        &self,
-        logs: &str,
-        _worktree_path: &str,
-    ) -> Result<crate::executor::NormalizedConversation, String> {
-        let mut entries = Vec::new();
-
-        // Add script command as first entry
-        entries.push(crate::executor::NormalizedEntry {
-            timestamp: None,
-            entry_type: crate::executor::NormalizedEntryType::SystemMessage,
-            content: format!("Executing setup script:\n{}", self.script),
-            metadata: None,
-        });
-
-        // Process the logs - split by lines and create entries
-        if !logs.trim().is_empty() {
-            let lines: Vec<&str> = logs.lines().collect();
-            let mut current_chunk = String::new();
-
-            for line in lines {
-                current_chunk.push_str(line);
-                current_chunk.push('\n');
-
-                // Create entry for every 10 lines or when we encounter an error-like line
-                if current_chunk.lines().count() >= 10
-                    || line.to_lowercase().contains("error")
-                    || line.to_lowercase().contains("failed")
-                    || line.to_lowercase().contains("exception")
-                {
-                    let entry_type = if line.to_lowercase().contains("error")
-                        || line.to_lowercase().contains("failed")
-                        || line.to_lowercase().contains("exception")
-                    {
-                        crate::executor::NormalizedEntryType::ErrorMessage
-                    } else {
-                        crate::executor::NormalizedEntryType::SystemMessage
-                    };
-
-                    entries.push(crate::executor::NormalizedEntry {
-                        timestamp: Some(chrono::Utc::now().to_rfc3339()),
-                        entry_type,
-                        content: current_chunk.trim().to_string(),
-                        metadata: None,
-                    });
-
-                    current_chunk.clear();
-                }
-            }
-
-            // Add any remaining content
-            if !current_chunk.trim().is_empty() {
-                entries.push(crate::executor::NormalizedEntry {
-                    timestamp: Some(chrono::Utc::now().to_rfc3339()),
-                    entry_type: crate::executor::NormalizedEntryType::SystemMessage,
-                    content: current_chunk.trim().to_string(),
-                    metadata: None,
-                });
-            }
-        }
-
-        Ok(crate::executor::NormalizedConversation {
-            entries,
-            session_id: None,
-            executor_type: "setup-script".to_string(),
-            prompt: Some(self.script.clone()),
-            summary: None,
-        })
-    }
-}

package/backend/src/executors/sst_opencode/filter.rs

@@ -1,184 +0,0 @@
-use lazy_static::lazy_static;
-use regex::Regex;
-
-lazy_static! {
-    static ref OPENCODE_LOG_REGEX: Regex = Regex::new(r"^(INFO|DEBUG|WARN|ERROR)\s+.*").unwrap();
-    static ref SESSION_ID_REGEX: Regex = Regex::new(r".*\b(id|session|sessionID)=([^ ]+)").unwrap();
-    static ref TOOL_USAGE_REGEX: Regex = Regex::new(r"^\|\s*([a-zA-Z]+)\s*(.*)").unwrap();
-    static ref NPM_WARN_REGEX: Regex = Regex::new(r"^npm warn .*").unwrap();
-}
-
-/// Filter for OpenCode stderr output
-pub struct OpenCodeFilter;
-
-impl OpenCodeFilter {
-    /// Check if a line should be skipped as noise
-    pub fn is_noise(line: &str) -> bool {
-        let trimmed = line.trim();
-
-        // Empty lines are noise
-        if trimmed.is_empty() {
-            return true;
-        }
-
-        // Strip ANSI escape codes for analysis
-        let cleaned = Self::strip_ansi_codes(trimmed);
-        let cleaned_trim = cleaned.trim();
-
-        // Skip tool calls - they are NOT noise
-        if TOOL_USAGE_REGEX.is_match(cleaned_trim) {
-            return false;
-        }
-
-        // OpenCode log lines are noise (includes session logs)
-        if is_opencode_log_line(cleaned_trim) {
-            return true;
-        }
-
-        if NPM_WARN_REGEX.is_match(cleaned_trim) {
-            return true;
-        }
-
-        // Spinner glyphs
-        if cleaned_trim.len() == 1 && "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏".contains(cleaned_trim) {
-            return true;
-        }
-
-        // Banner lines containing block glyphs (Unicode Block Elements range)
-        if cleaned_trim
-            .chars()
-            .any(|c| ('\u{2580}'..='\u{259F}').contains(&c))
-        {
-            return true;
-        }
-
-        // UI/stats frames using Box Drawing glyphs (U+2500-257F)
-        if cleaned_trim
-            .chars()
-            .any(|c| ('\u{2500}'..='\u{257F}').contains(&c))
-        {
-            return true;
-        }
-
-        // Model banner (@ with spaces)
-        if cleaned_trim.starts_with("@ ") {
-            return true;
-        }
-
-        // Share link
-        if cleaned_trim.starts_with("~") && cleaned_trim.contains("https://opencode.ai/s/") {
-            return true;
-        }
-
-        // Everything else (assistant messages) is NOT noise
-        false
-    }
-
-    pub fn is_stderr(_line: &str) -> bool {
-        false
-    }
-
-    /// Strip ANSI escape codes from text (conservative)
-    pub fn strip_ansi_codes(text: &str) -> String {
-        // Handle both unicode escape sequences and raw ANSI codes
-        let result = text.replace("\\u001b", "\x1b");
-
-        let mut cleaned = String::new();
-        let mut chars = result.chars().peekable();
-
-        while let Some(ch) = chars.next() {
-            if ch == '\x1b' {
-                // Skip ANSI escape sequence
-                if chars.peek() == Some(&'[') {
-                    chars.next(); // consume '['
-                                  // Skip until we find a letter (end of ANSI sequence)
-                    for next_ch in chars.by_ref() {
-                        if next_ch.is_ascii_alphabetic() {
-                            break;
-                        }
-                    }
-                }
-            } else {
-                cleaned.push(ch);
-            }
-        }
-
-        cleaned
-    }
-}
-
-/// Detect if a line is an OpenCode log line format using regex
-pub fn is_opencode_log_line(line: &str) -> bool {
-    OPENCODE_LOG_REGEX.is_match(line)
-}
-
-/// Parse session_id from OpenCode log lines
-pub fn parse_session_id_from_line(line: &str) -> Option<String> {
-    // Only apply to OpenCode log lines
-    if !is_opencode_log_line(line) {
-        return None;
-    }
-
-    // Try regex for session ID extraction from service=session logs
-    if let Some(captures) = SESSION_ID_REGEX.captures(line) {
-        if let Some(id) = captures.get(2) {
-            return Some(id.as_str().to_string());
-        }
-    }
-
-    None
-}
-
-/// Get the tool usage regex for parsing tool patterns
-pub fn tool_usage_regex() -> &'static Regex {
-    &TOOL_USAGE_REGEX
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_session_id_extraction() {
-        use crate::executors::sst_opencode::filter::parse_session_id_from_line;
-
-        // Test session ID extraction from session= format (only works on OpenCode log lines)
-        assert_eq!(
-            parse_session_id_from_line("INFO session=ses_abc123 starting"),
-            Some("ses_abc123".to_string())
-        );
-
-        assert_eq!(
-            parse_session_id_from_line("DEBUG id=debug_id process"),
-            Some("debug_id".to_string())
-        );
-
-        // Test lines without log prefix (should return None)
-        assert_eq!(
-            parse_session_id_from_line("session=simple_id chatting"),
-            None
-        );
-
-        // Test no session ID
-        assert_eq!(parse_session_id_from_line("No session here"), None);
-        assert_eq!(parse_session_id_from_line(""), None);
-    }
-
-    #[test]
-    fn test_ansi_code_stripping() {
-        use crate::executors::sst_opencode::filter::OpenCodeFilter;
-
-        // Test ANSI escape sequence removal
-        let ansi_text = "\x1b[31mRed text\x1b[0m normal text";
-        let cleaned = OpenCodeFilter::strip_ansi_codes(ansi_text);
-        assert_eq!(cleaned, "Red text normal text");
-
-        // Test unicode escape sequences
-        let unicode_ansi = "Text with \\u001b[32mgreen\\u001b[0m color";
-        let cleaned = OpenCodeFilter::strip_ansi_codes(unicode_ansi);
-        assert_eq!(cleaned, "Text with green color");
-
-        // Test text without ANSI codes (unchanged)
-        let plain_text = "Regular text without codes";
-        let cleaned = OpenCodeFilter::strip_ansi_codes(plain_text);
-        assert_eq!(cleaned, plain_text);
-    }
-}

package/backend/src/executors/sst_opencode/tools.rs

@@ -1,139 +0,0 @@
-use serde_json::{json, Value};
-
-use crate::utils::path::make_path_relative;
-
-/// Normalize tool names to match frontend expectations for purple box styling
-pub fn normalize_tool_name(tool_name: &str) -> String {
-    match tool_name {
-        "Todo" => "todowrite".to_string(), // Generic TODO tool → todowrite
-        "TodoWrite" => "todowrite".to_string(),
-        "TodoRead" => "todoread".to_string(),
-        _ => tool_name.to_string(),
-    }
-}
-
-/// Helper function to determine action type for tool usage
-pub fn determine_action_type(tool_name: &str, input: &Value, worktree_path: &str) -> Value {
-    match tool_name.to_lowercase().as_str() {
-        "read" => {
-            if let Some(file_path) = input.get("filePath").and_then(|p| p.as_str()) {
-                json!({
-                    "action": "file_read",
-                    "path": make_path_relative(file_path, worktree_path)
-                })
-            } else {
-                json!({"action": "other", "description": "File read operation"})
-            }
-        }
-        "write" | "edit" => {
-            if let Some(file_path) = input.get("filePath").and_then(|p| p.as_str()) {
-                json!({
-                    "action": "file_write",
-                    "path": make_path_relative(file_path, worktree_path)
-                })
-            } else {
-                json!({"action": "other", "description": "File write operation"})
-            }
-        }
-        "bash" => {
-            if let Some(command) = input.get("command").and_then(|c| c.as_str()) {
-                json!({"action": "command_run", "command": command})
-            } else {
-                json!({"action": "other", "description": "Command execution"})
-            }
-        }
-        "grep" => {
-            if let Some(pattern) = input.get("pattern").and_then(|p| p.as_str()) {
-                json!({"action": "search", "query": pattern})
-            } else {
-                json!({"action": "other", "description": "Search operation"})
-            }
-        }
-        "todowrite" | "todoread" => {
-            json!({"action": "other", "description": "TODO list management"})
-        }
-        _ => json!({"action": "other", "description": format!("Tool: {}", tool_name)}),
-    }
-}
-
-/// Helper function to generate concise content for tool usage
-pub fn generate_tool_content(tool_name: &str, input: &Value, worktree_path: &str) -> String {
-    match tool_name.to_lowercase().as_str() {
-        "read" => {
-            if let Some(file_path) = input.get("filePath").and_then(|p| p.as_str()) {
-                format!("`{}`", make_path_relative(file_path, worktree_path))
-            } else {
-                "Read file".to_string()
-            }
-        }
-        "write" | "edit" => {
-            if let Some(file_path) = input.get("filePath").and_then(|p| p.as_str()) {
-                format!("`{}`", make_path_relative(file_path, worktree_path))
-            } else {
-                "Write file".to_string()
-            }
-        }
-        "bash" => {
-            if let Some(command) = input.get("command").and_then(|c| c.as_str()) {
-                format!("`{}`", command)
-            } else {
-                "Execute command".to_string()
-            }
-        }
-        "todowrite" | "todoread" => generate_todo_content(input),
-        _ => format!("`{}`", tool_name),
-    }
-}
-
-/// Generate formatted content for TODO tools
-fn generate_todo_content(input: &Value) -> String {
-    // Extract todo list from input to show actual todos
-    if let Some(todos) = input.get("todos").and_then(|t| t.as_array()) {
-        let mut todo_items = Vec::new();
-        for todo in todos {
-            if let Some(content) = todo.get("content").and_then(|c| c.as_str()) {
-                let status = todo
-                    .get("status")
-                    .and_then(|s| s.as_str())
-                    .unwrap_or("pending");
-                let status_emoji = match status {
-                    "completed" => "✅",
-                    "in_progress" => "🔄",
-                    "pending" | "todo" => "⏳",
-                    _ => "📝",
-                };
-                let priority = todo
-                    .get("priority")
-                    .and_then(|p| p.as_str())
-                    .unwrap_or("medium");
-                todo_items.push(format!("{} {} ({})", status_emoji, content, priority));
-            }
-        }
-        if !todo_items.is_empty() {
-            format!("TODO List:\n{}", todo_items.join("\n"))
-        } else {
-            "Managing TODO list".to_string()
-        }
-    } else {
-        "Managing TODO list".to_string()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_normalize_tool_name() {
-        use crate::executors::sst_opencode::tools::normalize_tool_name;
-
-        // Test TODO tool normalization
-        assert_eq!(normalize_tool_name("Todo"), "todowrite");
-        assert_eq!(normalize_tool_name("TodoWrite"), "todowrite");
-        assert_eq!(normalize_tool_name("TodoRead"), "todoread");
-
-        // Test other tools remain unchanged
-        assert_eq!(normalize_tool_name("Read"), "Read");
-        assert_eq!(normalize_tool_name("Write"), "Write");
-        assert_eq!(normalize_tool_name("bash"), "bash");
-        assert_eq!(normalize_tool_name("SomeOtherTool"), "SomeOtherTool");
-    }
-}