automagik-forge 0.1.11 → 0.1.13

package/backend/src/routes/projects.rs

@@ -0,0 +1,562 @@
+use std::collections::HashMap;
+
+use axum::{
+    extract::{Query, State},
+    http::StatusCode,
+    response::Json as ResponseJson,
+    routing::get,
+    Extension, Json, Router,
+};
+use utoipa;
+use uuid::Uuid;
+
+use crate::{
+    app_state::AppState,
+    models::{
+        project::{
+            CreateBranch, CreateProject, GitBranch, Project, ProjectWithBranch, SearchMatchType,
+            SearchResult, UpdateProject,
+        },
+        ApiResponse,
+    },
+};
+
+#[utoipa::path(
+    get,
+    path = "/api/projects",
+    responses(
+        (status = 200, description = "List all projects", body = ApiResponse<Vec<Project>>),
+        (status = 500, description = "Internal server error")
+    ),
+    tag = "projects"
+)]
+pub async fn get_projects(
+    State(app_state): State<AppState>,
+) -> Result<ResponseJson<ApiResponse<Vec<Project>>>, StatusCode> {
+    match Project::find_all(&app_state.db_pool).await {
+        Ok(projects) => Ok(ResponseJson(ApiResponse::success(projects))),
+        Err(e) => {
+            tracing::error!("Failed to fetch projects: {}", e);
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+#[utoipa::path(
+    get,
+    path = "/api/projects/{id}",
+    params(
+        ("id" = String, Path, description = "Project ID")
+    ),
+    responses(
+        (status = 200, description = "Get project by ID", body = ApiResponse<Project>),
+        (status = 404, description = "Project not found"),
+        (status = 500, description = "Internal server error")
+    ),
+    tag = "projects"
+)]
+pub async fn get_project(
+    Extension(project): Extension<Project>,
+) -> Result<ResponseJson<ApiResponse<Project>>, StatusCode> {
+    Ok(ResponseJson(ApiResponse::success(project)))
+}
+
+pub async fn get_project_with_branch(
+    Extension(project): Extension<Project>,
+) -> Result<ResponseJson<ApiResponse<ProjectWithBranch>>, StatusCode> {
+    Ok(ResponseJson(ApiResponse::success(
+        project.with_branch_info(),
+    )))
+}
+
+pub async fn get_project_branches(
+    Extension(project): Extension<Project>,
+) -> Result<ResponseJson<ApiResponse<Vec<GitBranch>>>, StatusCode> {
+    match project.get_all_branches() {
+        Ok(branches) => Ok(ResponseJson(ApiResponse::success(branches))),
+        Err(e) => {
+            tracing::error!("Failed to get branches for project {}: {}", project.id, e);
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+pub async fn create_project_branch(
+    Extension(project): Extension<Project>,
+    Json(payload): Json<CreateBranch>,
+) -> Result<ResponseJson<ApiResponse<GitBranch>>, StatusCode> {
+    // Validate branch name
+    if payload.name.trim().is_empty() {
+        return Ok(ResponseJson(ApiResponse::error(
+            "Branch name cannot be empty",
+        )));
+    }
+
+    // Check if branch name contains invalid characters
+    if payload.name.contains(' ') {
+        return Ok(ResponseJson(ApiResponse::error(
+            "Branch name cannot contain spaces",
+        )));
+    }
+
+    match project.create_branch(&payload.name, payload.base_branch.as_deref()) {
+        Ok(branch) => Ok(ResponseJson(ApiResponse::success(branch))),
+        Err(e) => {
+            tracing::error!(
+                "Failed to create branch '{}' for project {}: {}",
+                payload.name,
+                project.id,
+                e
+            );
+            Ok(ResponseJson(ApiResponse::error(&format!(
+                "Failed to create branch: {}",
+                e
+            ))))
+        }
+    }
+}
+
+#[utoipa::path(
+    post,
+    path = "/api/projects",
+    request_body = CreateProject,
+    responses(
+        (status = 200, description = "Project created successfully", body = ApiResponse<Project>),
+        (status = 400, description = "Invalid input"),
+        (status = 500, description = "Internal server error")
+    ),
+    tag = "projects"
+)]
+pub async fn create_project(
+    State(app_state): State<AppState>,
+    Json(payload): Json<CreateProject>,
+) -> Result<ResponseJson<ApiResponse<Project>>, StatusCode> {
+    let id = Uuid::new_v4();
+
+    tracing::debug!("Creating project '{}'", payload.name);
+
+    // Check if git repo path is already used by another project
+    match Project::find_by_git_repo_path(&app_state.db_pool, &payload.git_repo_path).await {
+        Ok(Some(_)) => {
+            return Ok(ResponseJson(ApiResponse::error(
+                "A project with this git repository path already exists",
+            )));
+        }
+        Ok(None) => {
+            // Path is available, continue
+        }
+        Err(e) => {
+            tracing::error!("Failed to check for existing git repo path: {}", e);
+            return Err(StatusCode::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    // Validate and setup git repository
+    let path = std::path::Path::new(&payload.git_repo_path);
+
+    if payload.use_existing_repo {
+        // For existing repos, validate that the path exists and is a git repository
+        if !path.exists() {
+            return Ok(ResponseJson(ApiResponse::error(
+                "The specified path does not exist",
+            )));
+        }
+
+        if !path.is_dir() {
+            return Ok(ResponseJson(ApiResponse::error(
+                "The specified path is not a directory",
+            )));
+        }
+
+        if !path.join(".git").exists() {
+            return Ok(ResponseJson(ApiResponse::error(
+                "The specified directory is not a git repository",
+            )));
+        }
+    } else {
+        // For new repos, create directory and initialize git
+
+        // Create directory if it doesn't exist
+        if !path.exists() {
+            if let Err(e) = std::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 not initialize it
+        if !path.join(".git").exists() {
+            match std::process::Command::new("git")
+                .arg("init")
+                .current_dir(path)
+                .output()
+            {
+                Ok(output) => {
+                    if !output.status.success() {
+                        let error_msg = String::from_utf8_lossy(&output.stderr);
+                        tracing::error!("Git init failed: {}", error_msg);
+                        return Ok(ResponseJson(ApiResponse::error(&format!(
+                            "Git init failed: {}",
+                            error_msg
+                        ))));
+                    }
+                }
+                Err(e) => {
+                    tracing::error!("Failed to run git init: {}", e);
+                    return Ok(ResponseJson(ApiResponse::error(&format!(
+                        "Failed to run git init: {}",
+                        e
+                    ))));
+                }
+            }
+        }
+    }
+
+    match Project::create(&app_state.db_pool, &payload, id).await {
+        Ok(project) => {
+            // Track project creation event
+            app_state
+                .track_analytics_event(
+                    "project_created",
+                    Some(serde_json::json!({
+                        "project_id": project.id.to_string(),
+                        "use_existing_repo": payload.use_existing_repo,
+                        "has_setup_script": payload.setup_script.is_some(),
+                        "has_dev_script": payload.dev_script.is_some(),
+                    })),
+                )
+                .await;
+
+            Ok(ResponseJson(ApiResponse::success(project)))
+        }
+        Err(e) => {
+            tracing::error!("Failed to create project: {}", e);
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+#[utoipa::path(
+    put,
+    path = "/api/projects/{id}",
+    params(
+        ("id" = String, Path, description = "Project ID")
+    ),
+    request_body = UpdateProject,
+    responses(
+        (status = 200, description = "Project updated successfully", body = ApiResponse<Project>),
+        (status = 404, description = "Project not found"),
+        (status = 400, description = "Invalid input"),
+        (status = 500, description = "Internal server error")
+    ),
+    tag = "projects"
+)]
+pub async fn update_project(
+    Extension(existing_project): Extension<Project>,
+    State(app_state): State<AppState>,
+    Json(payload): Json<UpdateProject>,
+) -> Result<ResponseJson<ApiResponse<Project>>, StatusCode> {
+    // If git_repo_path is being changed, check if the new path is already used by another project
+    if let Some(new_git_repo_path) = &payload.git_repo_path {
+        if new_git_repo_path != &existing_project.git_repo_path {
+            match Project::find_by_git_repo_path_excluding_id(
+                &app_state.db_pool,
+                new_git_repo_path,
+                existing_project.id,
+            )
+            .await
+            {
+                Ok(Some(_)) => {
+                    return Ok(ResponseJson(ApiResponse::error(
+                        "A project with this git repository path already exists",
+                    )));
+                }
+                Ok(None) => {
+                    // Path is available, continue
+                }
+                Err(e) => {
+                    tracing::error!("Failed to check for existing git repo path: {}", e);
+                    return Err(StatusCode::INTERNAL_SERVER_ERROR);
+                }
+            }
+        }
+    }
+
+    // Destructure payload to handle field updates.
+    // This allows us to treat `None` from the payload as an explicit `null` to clear a field,
+    // as the frontend currently sends all fields on update.
+    let UpdateProject {
+        name,
+        git_repo_path,
+        setup_script,
+        dev_script,
+        cleanup_script,
+    } = payload;
+
+    let name = name.unwrap_or(existing_project.name);
+    let git_repo_path = git_repo_path.unwrap_or(existing_project.git_repo_path);
+
+    match Project::update(
+        &app_state.db_pool,
+        existing_project.id,
+        name,
+        git_repo_path,
+        setup_script,
+        dev_script,
+        cleanup_script,
+    )
+    .await
+    {
+        Ok(project) => Ok(ResponseJson(ApiResponse::success(project))),
+        Err(e) => {
+            tracing::error!("Failed to update project: {}", e);
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+#[utoipa::path(
+    delete,
+    path = "/api/projects/{id}",
+    params(
+        ("id" = String, Path, description = "Project ID")
+    ),
+    responses(
+        (status = 200, description = "Project deleted successfully"),
+        (status = 404, description = "Project not found"),
+        (status = 500, description = "Internal server error")
+    ),
+    tag = "projects"
+)]
+pub async fn delete_project(
+    Extension(project): Extension<Project>,
+    State(app_state): State<AppState>,
+) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
+    match Project::delete(&app_state.db_pool, project.id).await {
+        Ok(rows_affected) => {
+            if rows_affected == 0 {
+                Err(StatusCode::NOT_FOUND)
+            } else {
+                Ok(ResponseJson(ApiResponse::success(())))
+            }
+        }
+        Err(e) => {
+            tracing::error!("Failed to delete project: {}", e);
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+#[derive(serde::Deserialize)]
+pub struct OpenEditorRequest {
+    editor_type: Option<String>,
+}
+
+pub async fn open_project_in_editor(
+    Extension(project): Extension<Project>,
+    State(app_state): State<AppState>,
+    Json(payload): Json<Option<OpenEditorRequest>>,
+) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
+    // Get editor command from config or override
+    let editor_command = {
+        let config_guard = app_state.get_config().read().await;
+        if let Some(ref request) = payload {
+            if let Some(ref editor_type) = request.editor_type {
+                // Create a temporary editor config with the override
+                use crate::models::config::{EditorConfig, EditorType};
+                let override_editor_type = match editor_type.as_str() {
+                    "vscode" => EditorType::VSCode,
+                    "cursor" => EditorType::Cursor,
+                    "windsurf" => EditorType::Windsurf,
+                    "intellij" => EditorType::IntelliJ,
+                    "zed" => EditorType::Zed,
+                    "custom" => EditorType::Custom,
+                    _ => config_guard.editor.editor_type.clone(),
+                };
+                let temp_config = EditorConfig {
+                    editor_type: override_editor_type,
+                    custom_command: config_guard.editor.custom_command.clone(),
+                };
+                temp_config.get_command()
+            } else {
+                config_guard.editor.get_command()
+            }
+        } else {
+            config_guard.editor.get_command()
+        }
+    };
+
+    // Open editor in the project directory
+    let mut cmd = std::process::Command::new(&editor_command[0]);
+    for arg in &editor_command[1..] {
+        cmd.arg(arg);
+    }
+    cmd.arg(&project.git_repo_path);
+
+    match cmd.spawn() {
+        Ok(_) => {
+            tracing::info!(
+                "Opened editor ({}) for project {} at path: {}",
+                editor_command.join(" "),
+                project.id,
+                project.git_repo_path
+            );
+            Ok(ResponseJson(ApiResponse::success(())))
+        }
+        Err(e) => {
+            tracing::error!(
+                "Failed to open editor ({}) for project {}: {}",
+                editor_command.join(" "),
+                project.id,
+                e
+            );
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+pub async fn search_project_files(
+    Extension(project): Extension<Project>,
+    Query(params): Query<HashMap<String, String>>,
+) -> Result<ResponseJson<ApiResponse<Vec<SearchResult>>>, StatusCode> {
+    let query = match params.get("q") {
+        Some(q) if !q.trim().is_empty() => q.trim(),
+        _ => {
+            return Ok(ResponseJson(ApiResponse::error(
+                "Query parameter 'q' is required and cannot be empty",
+            )));
+        }
+    };
+
+    // Search files in the project repository
+    match search_files_in_repo(&project.git_repo_path, query).await {
+        Ok(results) => Ok(ResponseJson(ApiResponse::success(results))),
+        Err(e) => {
+            tracing::error!("Failed to search files: {}", e);
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+async fn search_files_in_repo(
+    repo_path: &str,
+    query: &str,
+) -> Result<Vec<SearchResult>, Box<dyn std::error::Error + Send + Sync>> {
+    use std::path::Path;
+
+    use ignore::WalkBuilder;
+
+    let repo_path = Path::new(repo_path);
+
+    if !repo_path.exists() {
+        return Err("Repository path does not exist".into());
+    }
+
+    let mut results = Vec::new();
+    let query_lower = query.to_lowercase();
+
+    // Use ignore::WalkBuilder to respect gitignore files
+    let walker = WalkBuilder::new(repo_path)
+        .git_ignore(true)
+        .git_global(true)
+        .git_exclude(true)
+        .hidden(false)
+        .build();
+
+    for result in walker {
+        let entry = result?;
+        let path = entry.path();
+
+        // Skip the root directory itself
+        if path == repo_path {
+            continue;
+        }
+
+        let relative_path = path.strip_prefix(repo_path)?;
+
+        // Skip .git directory and its contents
+        if relative_path
+            .components()
+            .any(|component| component.as_os_str() == ".git")
+        {
+            continue;
+        }
+        let relative_path_str = relative_path.to_string_lossy().to_lowercase();
+
+        let file_name = path
+            .file_name()
+            .map(|name| name.to_string_lossy().to_lowercase())
+            .unwrap_or_default();
+
+        // Check for matches
+        if file_name.contains(&query_lower) {
+            results.push(SearchResult {
+                path: relative_path.to_string_lossy().to_string(),
+                is_file: path.is_file(),
+                match_type: SearchMatchType::FileName,
+            });
+        } else if relative_path_str.contains(&query_lower) {
+            // Check if it's a directory name match or full path match
+            let match_type = if path
+                .parent()
+                .and_then(|p| p.file_name())
+                .map(|name| name.to_string_lossy().to_lowercase())
+                .unwrap_or_default()
+                .contains(&query_lower)
+            {
+                SearchMatchType::DirectoryName
+            } else {
+                SearchMatchType::FullPath
+            };
+
+            results.push(SearchResult {
+                path: relative_path.to_string_lossy().to_string(),
+                is_file: path.is_file(),
+                match_type,
+            });
+        }
+    }
+
+    // Sort results by priority: FileName > DirectoryName > FullPath
+    results.sort_by(|a, b| {
+        use SearchMatchType::*;
+        let priority = |match_type: &SearchMatchType| match match_type {
+            FileName => 0,
+            DirectoryName => 1,
+            FullPath => 2,
+        };
+
+        priority(&a.match_type)
+            .cmp(&priority(&b.match_type))
+            .then_with(|| a.path.cmp(&b.path))
+    });
+
+    // Limit to top 10 results
+    results.truncate(10);
+
+    Ok(results)
+}
+
+pub fn projects_base_router() -> Router<AppState> {
+    Router::new().route("/projects", get(get_projects).post(create_project))
+}
+
+pub fn projects_with_id_router() -> Router<AppState> {
+    use axum::routing::post;
+
+    Router::new()
+        .route(
+            "/projects/:id",
+            get(get_project).put(update_project).delete(delete_project),
+        )
+        .route("/projects/:id/with-branch", get(get_project_with_branch))
+        .route(
+            "/projects/:id/branches",
+            get(get_project_branches).post(create_project_branch),
+        )
+        .route("/projects/:id/search", get(search_project_files))
+        .route("/projects/:id/open-editor", post(open_project_in_editor))
+}