automagik-forge 0.1.11 → 0.1.13

package/backend/src/routes/config.rs

@@ -0,0 +1,385 @@
+use std::collections::HashMap;
+
+use axum::{
+    extract::{Query, State},
+    response::Json as ResponseJson,
+    routing::{get, post},
+    Json, Router,
+};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use tokio::fs;
+use ts_rs::TS;
+use utoipa::ToSchema;
+
+use crate::{
+    app_state::AppState,
+    executor::ExecutorConfig,
+    models::{
+        config::{Config, EditorConstants, SoundConstants},
+        ApiResponse,
+    },
+    utils,
+};
+
+pub fn config_router() -> Router<AppState> {
+    Router::new()
+        .route("/config", get(get_config))
+        .route("/config", post(update_config))
+        .route("/config/constants", get(get_config_constants))
+        .route("/mcp-servers", get(get_mcp_servers))
+        .route("/mcp-servers", post(update_mcp_servers))
+}
+
+#[utoipa::path(
+    get,
+    path = "/config",
+    tag = "config",
+    summary = "Get application configuration",
+    description = "Retrieves the current application configuration settings",
+    responses(
+        (status = 200, description = "Configuration retrieved successfully", body = ApiResponse<Config>)
+    )
+)]
+pub async fn get_config(State(app_state): State<AppState>) -> ResponseJson<ApiResponse<Config>> {
+    let config = app_state.get_config().read().await;
+    ResponseJson(ApiResponse::success(config.clone()))
+}
+
+#[utoipa::path(
+    post,
+    path = "/config",
+    tag = "config",
+    summary = "Update application configuration",
+    description = "Updates the application configuration with new settings",
+    request_body = Config,
+    responses(
+        (status = 200, description = "Configuration updated successfully", body = ApiResponse<Config>),
+        (status = 500, description = "Failed to save configuration", body = ApiResponse<String>)
+    )
+)]
+pub async fn update_config(
+    State(app_state): State<AppState>,
+    Json(new_config): Json<Config>,
+) -> ResponseJson<ApiResponse<Config>> {
+    let config_path = utils::config_path();
+
+    match new_config.save(&config_path) {
+        Ok(_) => {
+            let mut config = app_state.get_config().write().await;
+            *config = new_config.clone();
+            drop(config);
+
+            app_state
+                .update_analytics_config(new_config.analytics_enabled.unwrap_or(true))
+                .await;
+
+            ResponseJson(ApiResponse::success(new_config))
+        }
+        Err(e) => ResponseJson(ApiResponse::error(&format!("Failed to save config: {}", e))),
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, TS, ToSchema)]
+#[ts(export)]
+pub struct ConfigConstants {
+    pub editor: EditorConstants,
+    pub sound: SoundConstants,
+}
+
+#[utoipa::path(
+    get,
+    path = "/config/constants",
+    tag = "config",
+    summary = "Get configuration constants",
+    description = "Retrieves editor and sound constants for the application",
+    responses(
+        (status = 200, description = "Constants retrieved successfully", body = ApiResponse<ConfigConstants>)
+    )
+)]
+pub async fn get_config_constants() -> ResponseJson<ApiResponse<ConfigConstants>> {
+    let constants = ConfigConstants {
+        editor: EditorConstants::new(),
+        sound: SoundConstants::new(),
+    };
+
+    ResponseJson(ApiResponse::success(constants))
+}
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct McpServerQuery {
+    executor: Option<String>,
+}
+
+/// Common logic for resolving executor configuration and validating MCP support
+fn resolve_executor_config(
+    query_executor: Option<String>,
+    saved_config: &ExecutorConfig,
+) -> Result<ExecutorConfig, String> {
+    let executor_config = match query_executor {
+        Some(executor_type) => executor_type
+            .parse::<ExecutorConfig>()
+            .map_err(|e| e.to_string())?,
+        None => saved_config.clone(),
+    };
+
+    if !executor_config.supports_mcp() {
+        return Err(format!(
+            "{} executor does not support MCP configuration",
+            executor_config.display_name()
+        ));
+    }
+
+    Ok(executor_config)
+}
+
+#[utoipa::path(
+    get,
+    path = "/mcp-servers",
+    tag = "config",
+    summary = "Get MCP servers configuration",
+    description = "Retrieves MCP (Model Context Protocol) servers configuration for the specified executor",
+    params(
+        ("executor" = Option<String>, Query, description = "Executor type to get MCP servers for")
+    ),
+    responses(
+        (status = 200, description = "MCP servers retrieved successfully", body = ApiResponse<Value>),
+        (status = 400, description = "Executor does not support MCP or invalid configuration", body = ApiResponse<String>)
+    )
+)]
+pub async fn get_mcp_servers(
+    State(app_state): State<AppState>,
+    Query(query): Query<McpServerQuery>,
+) -> ResponseJson<ApiResponse<Value>> {
+    let saved_config = {
+        let config = app_state.get_config().read().await;
+        config.executor.clone()
+    };
+
+    let executor_config = match resolve_executor_config(query.executor, &saved_config) {
+        Ok(config) => config,
+        Err(message) => {
+            return ResponseJson(ApiResponse::error(&message));
+        }
+    };
+
+    // Get the config file path for this executor
+    let config_path = match executor_config.config_path() {
+        Some(path) => path,
+        None => {
+            return ResponseJson(ApiResponse::error("Could not determine config file path"));
+        }
+    };
+
+    match read_mcp_servers_from_config(&config_path, &executor_config).await {
+        Ok(servers) => {
+            let response_data = serde_json::json!({
+                "servers": servers,
+                "config_path": config_path.to_string_lossy().to_string()
+            });
+            ResponseJson(ApiResponse::success(response_data))
+        }
+        Err(e) => ResponseJson(ApiResponse::error(&format!(
+            "Failed to read MCP servers: {}",
+            e
+        ))),
+    }
+}
+
+#[utoipa::path(
+    post,
+    path = "/mcp-servers",
+    tag = "config",
+    summary = "Update MCP servers configuration",
+    description = "Updates MCP (Model Context Protocol) servers configuration for the specified executor",
+    params(
+        ("executor" = Option<String>, Query, description = "Executor type to update MCP servers for")
+    ),
+    request_body = HashMap<String, Value>,
+    responses(
+        (status = 200, description = "MCP servers updated successfully", body = ApiResponse<String>),
+        (status = 400, description = "Executor does not support MCP or update failed", body = ApiResponse<String>)
+    )
+)]
+pub async fn update_mcp_servers(
+    State(app_state): State<AppState>,
+    Query(query): Query<McpServerQuery>,
+    Json(new_servers): Json<HashMap<String, Value>>,
+) -> ResponseJson<ApiResponse<String>> {
+    let saved_config = {
+        let config = app_state.get_config().read().await;
+        config.executor.clone()
+    };
+
+    let executor_config = match resolve_executor_config(query.executor, &saved_config) {
+        Ok(config) => config,
+        Err(message) => {
+            return ResponseJson(ApiResponse::error(&message));
+        }
+    };
+
+    // Get the config file path for this executor
+    let config_path = match executor_config.config_path() {
+        Some(path) => path,
+        None => {
+            return ResponseJson(ApiResponse::error("Could not determine config file path"));
+        }
+    };
+
+    match update_mcp_servers_in_config(&config_path, &executor_config, new_servers).await {
+        Ok(message) => ResponseJson(ApiResponse::success(message)),
+        Err(e) => ResponseJson(ApiResponse::error(&format!(
+            "Failed to update MCP servers: {}",
+            e
+        ))),
+    }
+}
+
+async fn update_mcp_servers_in_config(
+    file_path: &std::path::Path,
+    executor_config: &ExecutorConfig,
+    new_servers: HashMap<String, Value>,
+) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+    // Ensure parent directory exists
+    if let Some(parent) = file_path.parent() {
+        fs::create_dir_all(parent).await?;
+    }
+
+    // Read existing config file or create empty object if it doesn't exist
+    let file_content = fs::read_to_string(file_path)
+        .await
+        .unwrap_or_else(|_| "{}".to_string());
+    let mut config: Value = serde_json::from_str(&file_content)?;
+
+    // Get the attribute path for MCP servers
+    let mcp_path = executor_config.mcp_attribute_path().unwrap();
+
+    // Get the current server count for comparison
+    let old_servers = get_mcp_servers_from_config_path(&config, &mcp_path).len();
+
+    // Set the MCP servers using the correct attribute path
+    set_mcp_servers_in_config_path(&mut config, &mcp_path, &new_servers)?;
+
+    // Write the updated config back to file
+    let updated_content = serde_json::to_string_pretty(&config)?;
+    fs::write(file_path, updated_content).await?;
+
+    let new_count = new_servers.len();
+    let message = match (old_servers, new_count) {
+        (0, 0) => "No MCP servers configured".to_string(),
+        (0, n) => format!("Added {} MCP server(s)", n),
+        (old, new) if old == new => format!("Updated MCP server configuration ({} server(s))", new),
+        (old, new) => format!(
+            "Updated MCP server configuration (was {}, now {})",
+            old, new
+        ),
+    };
+
+    Ok(message)
+}
+
+async fn read_mcp_servers_from_config(
+    file_path: &std::path::Path,
+    executor_config: &ExecutorConfig,
+) -> Result<HashMap<String, Value>, Box<dyn std::error::Error + Send + Sync>> {
+    // Read the config file, return empty if it doesn't exist
+    let file_content = fs::read_to_string(file_path)
+        .await
+        .unwrap_or_else(|_| "{}".to_string());
+    let config: Value = serde_json::from_str(&file_content)?;
+
+    // Get the attribute path for MCP servers
+    let mcp_path = executor_config.mcp_attribute_path().unwrap();
+
+    // Get the servers using the correct attribute path
+    let servers = get_mcp_servers_from_config_path(&config, &mcp_path);
+
+    Ok(servers)
+}
+
+/// Helper function to get MCP servers from config using a path
+fn get_mcp_servers_from_config_path(config: &Value, path: &[&str]) -> HashMap<String, Value> {
+    // Special handling for AMP - use flat key structure
+    if path.len() == 2 && path[0] == "amp" && path[1] == "mcpServers" {
+        let flat_key = format!("{}.{}", path[0], path[1]);
+        let current = match config.get(&flat_key) {
+            Some(val) => val,
+            None => return HashMap::new(),
+        };
+
+        // Extract the servers object
+        match current.as_object() {
+            Some(servers) => servers
+                .iter()
+                .map(|(k, v)| (k.clone(), v.clone()))
+                .collect(),
+            None => HashMap::new(),
+        }
+    } else {
+        let mut current = config;
+
+        // Navigate to the target location
+        for &part in path {
+            current = match current.get(part) {
+                Some(val) => val,
+                None => return HashMap::new(),
+            };
+        }
+
+        // Extract the servers object
+        match current.as_object() {
+            Some(servers) => servers
+                .iter()
+                .map(|(k, v)| (k.clone(), v.clone()))
+                .collect(),
+            None => HashMap::new(),
+        }
+    }
+}
+
+/// Helper function to set MCP servers in config using a path
+fn set_mcp_servers_in_config_path(
+    config: &mut Value,
+    path: &[&str],
+    servers: &HashMap<String, Value>,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    // Ensure config is an object
+    if !config.is_object() {
+        *config = serde_json::json!({});
+    }
+
+    // Special handling for AMP - use flat key structure
+    if path.len() == 2 && path[0] == "amp" && path[1] == "mcpServers" {
+        let flat_key = format!("{}.{}", path[0], path[1]);
+        config
+            .as_object_mut()
+            .unwrap()
+            .insert(flat_key, serde_json::to_value(servers)?);
+        return Ok(());
+    }
+
+    let mut current = config;
+
+    // Navigate/create the nested structure (all parts except the last)
+    for &part in &path[..path.len() - 1] {
+        if current.get(part).is_none() {
+            current
+                .as_object_mut()
+                .unwrap()
+                .insert(part.to_string(), serde_json::json!({}));
+        }
+        current = current.get_mut(part).unwrap();
+        if !current.is_object() {
+            *current = serde_json::json!({});
+        }
+    }
+
+    // Set the final attribute
+    let final_attr = path.last().unwrap();
+    current
+        .as_object_mut()
+        .unwrap()
+        .insert(final_attr.to_string(), serde_json::to_value(servers)?);
+
+    Ok(())
+}

package/backend/src/routes/filesystem.rs

@@ -0,0 +1,228 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use axum::{
+    extract::Query, http::StatusCode, response::Json as ResponseJson, routing::get, Router,
+};
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+use utoipa::ToSchema;
+
+use crate::{app_state::AppState, models::ApiResponse};
+
+#[derive(Debug, Serialize, TS, ToSchema)]
+#[ts(export)]
+pub struct DirectoryEntry {
+    pub name: String,
+    pub path: String,
+    pub is_directory: bool,
+    pub is_git_repo: bool,
+}
+
+#[derive(Debug, Serialize, TS, ToSchema)]
+#[ts(export)]
+pub struct DirectoryListResponse {
+    pub entries: Vec<DirectoryEntry>,
+    pub current_path: String,
+}
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct ListDirectoryQuery {
+    path: Option<String>,
+}
+
+#[utoipa::path(
+    get,
+    path = "/filesystem/list",
+    tag = "filesystem",
+    summary = "List directory contents",
+    description = "Lists files and directories at the specified path, with Git repository detection",
+    params(
+        ("path" = Option<String>, Query, description = "Directory path to list (defaults to home directory)")
+    ),
+    responses(
+        (status = 200, description = "Directory contents retrieved successfully", body = ApiResponse<DirectoryListResponse>),
+        (status = 404, description = "Directory not found or access denied")
+    )
+)]
+pub async fn list_directory(
+    Query(query): Query<ListDirectoryQuery>,
+) -> Result<ResponseJson<ApiResponse<DirectoryListResponse>>, StatusCode> {
+    let path_str = query.path.unwrap_or_else(|| {
+        // Default to user's home directory
+        dirs::home_dir()
+            .or_else(dirs::desktop_dir)
+            .or_else(dirs::document_dir)
+            .unwrap_or_else(|| {
+                if cfg!(windows) {
+                    std::env::var("USERPROFILE")
+                        .map(PathBuf::from)
+                        .unwrap_or_else(|_| PathBuf::from("C:\\"))
+                } else {
+                    PathBuf::from("/")
+                }
+            })
+            .to_string_lossy()
+            .to_string()
+    });
+
+    let path = Path::new(&path_str);
+
+    if !path.exists() {
+        return Ok(ResponseJson(ApiResponse::error("Directory does not exist")));
+    }
+
+    if !path.is_dir() {
+        return Ok(ResponseJson(ApiResponse::error("Path is not a directory")));
+    }
+
+    match fs::read_dir(path) {
+        Ok(entries) => {
+            let mut directory_entries = Vec::new();
+
+            for entry in entries.flatten() {
+                let path = entry.path();
+                let metadata = entry.metadata().ok();
+
+                if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+                    // Skip hidden files/directories
+                    if name.starts_with('.') && name != ".." {
+                        continue;
+                    }
+
+                    let is_directory = metadata.is_some_and(|m| m.is_dir());
+                    let is_git_repo = if is_directory {
+                        path.join(".git").exists()
+                    } else {
+                        false
+                    };
+
+                    directory_entries.push(DirectoryEntry {
+                        name: name.to_string(),
+                        path: path.to_string_lossy().to_string(),
+                        is_directory,
+                        is_git_repo,
+                    });
+                }
+            }
+
+            // Sort: directories first, then files, both alphabetically
+            directory_entries.sort_by(|a, b| match (a.is_directory, b.is_directory) {
+                (true, false) => std::cmp::Ordering::Less,
+                (false, true) => std::cmp::Ordering::Greater,
+                _ => a.name.to_lowercase().cmp(&b.name.to_lowercase()),
+            });
+
+            Ok(ResponseJson(ApiResponse::success(DirectoryListResponse {
+                entries: directory_entries,
+                current_path: path.to_string_lossy().to_string(),
+            })))
+        }
+        Err(e) => {
+            tracing::error!("Failed to read directory: {}", e);
+            Ok(ResponseJson(ApiResponse::error(&format!(
+                "Failed to read directory: {}",
+                e
+            ))))
+        }
+    }
+}
+
+#[utoipa::path(
+    get,
+    path = "/filesystem/validate-git",
+    tag = "filesystem",
+    summary = "Validate Git repository path",
+    description = "Checks if the specified path exists and is a valid Git repository",
+    params(
+        ("path" = String, Query, description = "Directory path to validate as Git repository")
+    ),
+    responses(
+        (status = 200, description = "Path validation result", body = ApiResponse<bool>),
+        (status = 400, description = "Missing or invalid path parameter")
+    )
+)]
+pub async fn validate_git_path(
+    Query(query): Query<ListDirectoryQuery>,
+) -> Result<ResponseJson<ApiResponse<bool>>, StatusCode> {
+    let path_str = query.path.ok_or(StatusCode::BAD_REQUEST)?;
+    let path = Path::new(&path_str);
+
+    // Check if path exists and is a git repo
+    let is_valid_git_repo = path.exists() && path.is_dir() && path.join(".git").exists();
+
+    Ok(ResponseJson(ApiResponse::success(is_valid_git_repo)))
+}
+
+#[utoipa::path(
+    get,
+    path = "/filesystem/create-git",
+    tag = "filesystem",
+    summary = "Initialize Git repository",
+    description = "Creates a directory if needed and initializes it as a Git repository",
+    params(
+        ("path" = String, Query, description = "Directory path where Git repository should be created")
+    ),
+    responses(
+        (status = 200, description = "Git repository created or already exists"),
+        (status = 400, description = "Missing path parameter or Git initialization failed")
+    )
+)]
+pub async fn create_git_repo(
+    Query(query): Query<ListDirectoryQuery>,
+) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
+    let path_str = query.path.ok_or(StatusCode::BAD_REQUEST)?;
+    let path = Path::new(&path_str);
+
+    // Create directory if it doesn't exist
+    if !path.exists() {
+        if let Err(e) = fs::create_dir_all(path) {
+            tracing::error!("Failed to create directory: {}", e);
+            return Ok(ResponseJson(ApiResponse::error(&format!(
+                "Failed to create directory: {}",
+                e
+            ))));
+        }
+    }
+
+    // Check if it's already a git repo
+    if path.join(".git").exists() {
+        return Ok(ResponseJson(ApiResponse::success(())));
+    }
+
+    // Initialize git repository
+    match std::process::Command::new("git")
+        .arg("init")
+        .current_dir(path)
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                Ok(ResponseJson(ApiResponse::success(())))
+            } else {
+                let error_msg = String::from_utf8_lossy(&output.stderr);
+                tracing::error!("Git init failed: {}", error_msg);
+                Ok(ResponseJson(ApiResponse::error(&format!(
+                    "Git init failed: {}",
+                    error_msg
+                ))))
+            }
+        }
+        Err(e) => {
+            tracing::error!("Failed to run git init: {}", e);
+            Ok(ResponseJson(ApiResponse::error(&format!(
+                "Failed to run git init: {}",
+                e
+            ))))
+        }
+    }
+}
+
+pub fn filesystem_router() -> Router<AppState> {
+    Router::new()
+        .route("/filesystem/list", get(list_directory))
+        .route("/filesystem/validate-git", get(validate_git_path))
+        .route("/filesystem/create-git", get(create_git_repo))
+}

package/backend/src/routes/health.rs

@@ -0,0 +1,16 @@
+use axum::response::Json;
+use utoipa;
+
+use crate::models::ApiResponse;
+
+#[utoipa::path(
+    get,
+    path = "/api/health",
+    responses(
+        (status = 200, description = "Health check successful", body = ApiResponse<String>)
+    ),
+    tag = "health"
+)]
+pub async fn health_check() -> Json<ApiResponse<String>> {
+    Json(ApiResponse::success("OK".to_string()))
+}

package/backend/src/routes/mod.rs

@@ -0,0 +1,9 @@
+pub mod auth;
+pub mod config;
+pub mod filesystem;
+pub mod health;
+pub mod projects;
+pub mod stream;
+pub mod task_attempts;
+pub mod task_templates;
+pub mod tasks;