automagik-forge 0.1.13 → 0.1.14

package/backend/src/routes/config.rs

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

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

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

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