automagik-forge 0.1.11 → 0.1.13

package/backend/src/executors/mod.rs

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,184 @@
+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

@@ -0,0 +1,139 @@
+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");
+    }
+}