automagik-forge 0.1.11 → 0.1.13

package/backend/src/routes/task_templates.rs

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

@@ -0,0 +1,353 @@
+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),
+    )
+}