automagik-forge 0.1.13 → 0.1.14

package/backend/src/routes/task_templates.rs

@@ -1,229 +0,0 @@
-use axum::{
-    extract::{Path, State},
-    http::StatusCode,
-    response::IntoResponse,
-    Extension, Json,
-};
-use utoipa;
-use uuid::Uuid;
-
-use crate::{
-    app_state::AppState,
-    models::{
-        api_response::ApiResponse,
-        task_template::{CreateTaskTemplate, TaskTemplate, UpdateTaskTemplate},
-    },
-};
-
-#[utoipa::path(
-    get,
-    path = "/api/task-templates",
-    responses(
-        (status = 200, description = "List all task templates", body = ApiResponse<Vec<TaskTemplate>>),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_templates"
-)]
-pub async fn list_templates(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, (StatusCode, Json<ApiResponse<()>>)> {
-    match TaskTemplate::find_all(&state.db_pool).await {
-        Ok(templates) => Ok(Json(ApiResponse::success(templates))),
-        Err(e) => Err((
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Json(ApiResponse::error(&format!(
-                "Failed to fetch templates: {}",
-                e
-            ))),
-        )),
-    }
-}
-
-#[utoipa::path(
-    get,
-    path = "/api/projects/{project_id}/task-templates",
-    params(
-        ("project_id" = String, Path, description = "Project ID")
-    ),
-    responses(
-        (status = 200, description = "List project-specific task templates", body = ApiResponse<Vec<TaskTemplate>>),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_templates"
-)]
-pub async fn list_project_templates(
-    State(state): State<AppState>,
-    Path(project_id): Path<Uuid>,
-) -> Result<impl IntoResponse, (StatusCode, Json<ApiResponse<()>>)> {
-    match TaskTemplate::find_by_project_id(&state.db_pool, Some(project_id)).await {
-        Ok(templates) => Ok(Json(ApiResponse::success(templates))),
-        Err(e) => Err((
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Json(ApiResponse::error(&format!(
-                "Failed to fetch templates: {}",
-                e
-            ))),
-        )),
-    }
-}
-
-#[utoipa::path(
-    get,
-    path = "/api/task-templates/global",
-    responses(
-        (status = 200, description = "List global task templates", body = ApiResponse<Vec<TaskTemplate>>),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_templates"
-)]
-pub async fn list_global_templates(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, (StatusCode, Json<ApiResponse<()>>)> {
-    match TaskTemplate::find_by_project_id(&state.db_pool, None).await {
-        Ok(templates) => Ok(Json(ApiResponse::success(templates))),
-        Err(e) => Err((
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Json(ApiResponse::error(&format!(
-                "Failed to fetch global templates: {}",
-                e
-            ))),
-        )),
-    }
-}
-
-#[utoipa::path(
-    get,
-    path = "/api/task-templates/{template_id}",
-    params(
-        ("template_id" = String, Path, description = "Template ID")
-    ),
-    responses(
-        (status = 200, description = "Get task template by ID", body = ApiResponse<TaskTemplate>),
-        (status = 404, description = "Template not found")
-    ),
-    tag = "task_templates"
-)]
-pub async fn get_template(
-    Extension(template): Extension<TaskTemplate>,
-) -> Result<impl IntoResponse, (StatusCode, Json<ApiResponse<()>>)> {
-    Ok(Json(ApiResponse::success(template)))
-}
-
-#[utoipa::path(
-    post,
-    path = "/api/task-templates",
-    request_body = CreateTaskTemplate,
-    responses(
-        (status = 201, description = "Task template created successfully", body = ApiResponse<TaskTemplate>),
-        (status = 409, description = "Template name already exists"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_templates"
-)]
-pub async fn create_template(
-    State(state): State<AppState>,
-    Json(payload): Json<CreateTaskTemplate>,
-) -> Result<impl IntoResponse, (StatusCode, Json<ApiResponse<()>>)> {
-    match TaskTemplate::create(&state.db_pool, &payload).await {
-        Ok(template) => Ok((StatusCode::CREATED, Json(ApiResponse::success(template)))),
-        Err(e) => {
-            if e.to_string().contains("UNIQUE constraint failed") {
-                Err((
-                    StatusCode::CONFLICT,
-                    Json(ApiResponse::error(
-                        "A template with this name already exists in this scope",
-                    )),
-                ))
-            } else {
-                Err((
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    Json(ApiResponse::error(&format!(
-                        "Failed to create template: {}",
-                        e
-                    ))),
-                ))
-            }
-        }
-    }
-}
-
-#[utoipa::path(
-    put,
-    path = "/api/task-templates/{template_id}",
-    params(
-        ("template_id" = String, Path, description = "Template ID")
-    ),
-    request_body = UpdateTaskTemplate,
-    responses(
-        (status = 200, description = "Task template updated successfully", body = ApiResponse<TaskTemplate>),
-        (status = 404, description = "Template not found"),
-        (status = 409, description = "Template name already exists"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_templates"
-)]
-pub async fn update_template(
-    Extension(template): Extension<TaskTemplate>,
-    State(state): State<AppState>,
-    Json(payload): Json<UpdateTaskTemplate>,
-) -> Result<impl IntoResponse, (StatusCode, Json<ApiResponse<()>>)> {
-    match TaskTemplate::update(&state.db_pool, template.id, &payload).await {
-        Ok(template) => Ok(Json(ApiResponse::success(template))),
-        Err(e) => {
-            if matches!(e, sqlx::Error::RowNotFound) {
-                Err((
-                    StatusCode::NOT_FOUND,
-                    Json(ApiResponse::error("Template not found")),
-                ))
-            } else if e.to_string().contains("UNIQUE constraint failed") {
-                Err((
-                    StatusCode::CONFLICT,
-                    Json(ApiResponse::error(
-                        "A template with this name already exists in this scope",
-                    )),
-                ))
-            } else {
-                Err((
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    Json(ApiResponse::error(&format!(
-                        "Failed to update template: {}",
-                        e
-                    ))),
-                ))
-            }
-        }
-    }
-}
-
-#[utoipa::path(
-    delete,
-    path = "/api/task-templates/{template_id}",
-    params(
-        ("template_id" = String, Path, description = "Template ID")
-    ),
-    responses(
-        (status = 200, description = "Task template deleted successfully"),
-        (status = 404, description = "Template not found"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_templates"
-)]
-pub async fn delete_template(
-    Extension(template): Extension<TaskTemplate>,
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, (StatusCode, Json<ApiResponse<()>>)> {
-    match TaskTemplate::delete(&state.db_pool, template.id).await {
-        Ok(0) => Err((
-            StatusCode::NOT_FOUND,
-            Json(ApiResponse::error("Template not found")),
-        )),
-        Ok(_) => Ok(Json(ApiResponse::success(()))),
-        Err(e) => Err((
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Json(ApiResponse::error(&format!(
-                "Failed to delete template: {}",
-                e
-            ))),
-        )),
-    }
-}

package/backend/src/routes/tasks.rs

@@ -1,353 +0,0 @@
-use axum::{
-    extract::State, http::StatusCode, response::Json as ResponseJson, routing::get, Extension,
-    Json, Router,
-};
-use utoipa;
-use uuid::Uuid;
-
-use crate::{
-    app_state::AppState,
-    execution_monitor,
-    models::{
-        project::Project,
-        task::{CreateTask, CreateTaskAndStart, Task, TaskWithAttemptStatus, UpdateTask},
-        task_attempt::{CreateTaskAttempt, TaskAttempt},
-        ApiResponse,
-    },
-};
-
-#[utoipa::path(
-    get,
-    path = "/api/projects/{project_id}/tasks",
-    params(
-        ("project_id" = String, Path, description = "Project ID")
-    ),
-    responses(
-        (status = 200, description = "List all tasks for a project", body = ApiResponse<Vec<TaskWithAttemptStatus>>),
-        (status = 404, description = "Project not found"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "tasks"
-)]
-pub async fn get_project_tasks(
-    Extension(project): Extension<Project>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<Vec<TaskWithAttemptStatus>>>, StatusCode> {
-    match Task::find_by_project_id_with_attempt_status(&app_state.db_pool, project.id).await {
-        Ok(tasks) => Ok(ResponseJson(ApiResponse::success(tasks))),
-        Err(e) => {
-            tracing::error!("Failed to fetch tasks for project {}: {}", project.id, e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-#[utoipa::path(
-    get,
-    path = "/api/projects/{project_id}/tasks/{task_id}",
-    params(
-        ("project_id" = String, Path, description = "Project ID"),
-        ("task_id" = String, Path, description = "Task ID")
-    ),
-    responses(
-        (status = 200, description = "Get task by ID", body = ApiResponse<Task>),
-        (status = 404, description = "Task not found"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "tasks"
-)]
-pub async fn get_task(
-    Extension(task): Extension<Task>,
-) -> Result<ResponseJson<ApiResponse<Task>>, StatusCode> {
-    Ok(ResponseJson(ApiResponse::success(task)))
-}
-
-#[utoipa::path(
-    post,
-    path = "/api/projects/{project_id}/tasks",
-    params(
-        ("project_id" = String, Path, description = "Project ID")
-    ),
-    request_body = CreateTask,
-    responses(
-        (status = 200, description = "Task created successfully", body = ApiResponse<Task>),
-        (status = 400, description = "Invalid input"),
-        (status = 404, description = "Project not found"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "tasks"
-)]
-pub async fn create_task(
-    Extension(project): Extension<Project>,
-    State(app_state): State<AppState>,
-    Json(mut payload): Json<CreateTask>,
-) -> Result<ResponseJson<ApiResponse<Task>>, StatusCode> {
-    let id = Uuid::new_v4();
-
-    // Ensure the project_id in the payload matches the project from middleware
-    payload.project_id = project.id;
-
-    tracing::debug!(
-        "Creating task '{}' in project {}",
-        payload.title,
-        project.id
-    );
-
-    match Task::create(&app_state.db_pool, &payload, id).await {
-        Ok(task) => {
-            // Track task creation event
-            app_state
-                .track_analytics_event(
-                    "task_created",
-                    Some(serde_json::json!({
-                    "task_id": task.id.to_string(),
-                    "project_id": project.id.to_string(),
-                    "has_description": task.description.is_some(),
-                    })),
-                )
-                .await;
-
-            Ok(ResponseJson(ApiResponse::success(task)))
-        }
-        Err(e) => {
-            tracing::error!("Failed to create task: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-pub async fn create_task_and_start(
-    Extension(project): Extension<Project>,
-    State(app_state): State<AppState>,
-    Json(mut payload): Json<CreateTaskAndStart>,
-) -> Result<ResponseJson<ApiResponse<Task>>, StatusCode> {
-    let task_id = Uuid::new_v4();
-
-    // Ensure the project_id in the payload matches the project from middleware
-    payload.project_id = project.id;
-
-    tracing::debug!(
-        "Creating and starting task '{}' in project {}",
-        payload.title,
-        project.id
-    );
-
-    // Create the task first
-    let create_task_payload = CreateTask {
-        project_id: payload.project_id,
-        title: payload.title.clone(),
-        description: payload.description.clone(),
-        wish_id: payload.wish_id.clone(),
-        parent_task_attempt: payload.parent_task_attempt,
-    };
-    let task = match Task::create(&app_state.db_pool, &create_task_payload, task_id).await {
-        Ok(task) => task,
-        Err(e) => {
-            tracing::error!("Failed to create task: {}", e);
-            return Err(StatusCode::INTERNAL_SERVER_ERROR);
-        }
-    };
-
-    // Create task attempt
-    let executor_string = payload.executor.as_ref().map(|exec| exec.to_string());
-    let attempt_payload = CreateTaskAttempt {
-        executor: executor_string.clone(),
-        base_branch: None, // Not supported in task creation endpoint, only in task attempts
-    };
-
-    match TaskAttempt::create(&app_state.db_pool, &attempt_payload, task_id).await {
-        Ok(attempt) => {
-            app_state
-                .track_analytics_event(
-                    "task_created",
-                    Some(serde_json::json!({
-                        "task_id": task.id.to_string(),
-                        "project_id": project.id.to_string(),
-                        "has_description": task.description.is_some(),
-                    })),
-                )
-                .await;
-
-            app_state
-                .track_analytics_event(
-                    "task_attempt_started",
-                    Some(serde_json::json!({
-                        "task_id": task.id.to_string(),
-                        "executor_type": executor_string.as_deref().unwrap_or("default"),
-                        "attempt_id": attempt.id.to_string(),
-                    })),
-                )
-                .await;
-
-            // Start execution asynchronously (don't block the response)
-            let app_state_clone = app_state.clone();
-            let attempt_id = attempt.id;
-            tokio::spawn(async move {
-                if let Err(e) = TaskAttempt::start_execution(
-                    &app_state_clone.db_pool,
-                    &app_state_clone,
-                    attempt_id,
-                    task_id,
-                    project.id,
-                )
-                .await
-                {
-                    tracing::error!(
-                        "Failed to start execution for task attempt {}: {}",
-                        attempt_id,
-                        e
-                    );
-                }
-            });
-
-            Ok(ResponseJson(ApiResponse::success(task)))
-        }
-        Err(e) => {
-            tracing::error!("Failed to create task attempt: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-#[utoipa::path(
-    put,
-    path = "/api/projects/{project_id}/tasks/{task_id}",
-    params(
-        ("project_id" = String, Path, description = "Project ID"),
-        ("task_id" = String, Path, description = "Task ID")
-    ),
-    request_body = UpdateTask,
-    responses(
-        (status = 200, description = "Task updated successfully", body = ApiResponse<Task>),
-        (status = 404, description = "Task or project not found"),
-        (status = 400, description = "Invalid input"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "tasks"
-)]
-pub async fn update_task(
-    Extension(project): Extension<Project>,
-    Extension(existing_task): Extension<Task>,
-    State(app_state): State<AppState>,
-    Json(payload): Json<UpdateTask>,
-) -> Result<ResponseJson<ApiResponse<Task>>, StatusCode> {
-    // Use existing values if not provided in update
-    let title = payload.title.unwrap_or(existing_task.title);
-    let description = payload.description.or(existing_task.description);
-    let status = payload.status.unwrap_or(existing_task.status);
-    let wish_id = payload.wish_id.unwrap_or(existing_task.wish_id);
-    let parent_task_attempt = payload
-        .parent_task_attempt
-        .or(existing_task.parent_task_attempt);
-
-    match Task::update(
-        &app_state.db_pool,
-        existing_task.id,
-        project.id,
-        title,
-        description,
-        status,
-        wish_id,
-        parent_task_attempt,
-    )
-    .await
-    {
-        Ok(task) => Ok(ResponseJson(ApiResponse::success(task))),
-        Err(e) => {
-            tracing::error!("Failed to update task: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-#[utoipa::path(
-    delete,
-    path = "/api/projects/{project_id}/tasks/{task_id}",
-    params(
-        ("project_id" = String, Path, description = "Project ID"),
-        ("task_id" = String, Path, description = "Task ID")
-    ),
-    responses(
-        (status = 200, description = "Task deleted successfully"),
-        (status = 404, description = "Task or project not found"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "tasks"
-)]
-pub async fn delete_task(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    // Clean up all worktrees for this task before deletion
-    if let Err(e) = execution_monitor::cleanup_task_worktrees(&app_state.db_pool, task.id).await {
-        tracing::error!("Failed to cleanup worktrees for task {}: {}", task.id, e);
-        // Continue with deletion even if cleanup fails
-    }
-
-    // Clean up all executor sessions for this task before deletion
-    match TaskAttempt::find_by_task_id(&app_state.db_pool, task.id).await {
-        Ok(task_attempts) => {
-            for attempt in task_attempts {
-                if let Err(e) =
-                    crate::models::executor_session::ExecutorSession::delete_by_task_attempt_id(
-                        &app_state.db_pool,
-                        attempt.id,
-                    )
-                    .await
-                {
-                    tracing::error!(
-                        "Failed to cleanup executor sessions for task attempt {}: {}",
-                        attempt.id,
-                        e
-                    );
-                    // Continue with deletion even if session cleanup fails
-                } else {
-                    tracing::debug!(
-                        "Cleaned up executor sessions for task attempt {}",
-                        attempt.id
-                    );
-                }
-            }
-        }
-        Err(e) => {
-            tracing::error!("Failed to get task attempts for session cleanup: {}", e);
-            // Continue with deletion even if we can't get task attempts
-        }
-    }
-
-    match Task::delete(&app_state.db_pool, task.id, 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 task: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-pub fn tasks_project_router() -> Router<AppState> {
-    use axum::routing::post;
-
-    Router::new()
-        .route(
-            "/projects/:project_id/tasks",
-            get(get_project_tasks).post(create_task),
-        )
-        .route(
-            "/projects/:project_id/tasks/create-and-start",
-            post(create_task_and_start),
-        )
-}
-
-pub fn tasks_with_id_router() -> Router<AppState> {
-    Router::new().route(
-        "/projects/:project_id/tasks/:task_id",
-        get(get_task).put(update_task).delete(delete_task),
-    )
-}