automagik-forge 0.1.13 → 0.1.14

package/backend/src/routes/task_attempts.rs

@@ -1,1172 +0,0 @@
-use axum::{
-    extract::{Query, State},
-    http::StatusCode,
-    middleware::from_fn_with_state,
-    response::Json as ResponseJson,
-    routing::get,
-    Extension, Json, Router,
-};
-use serde::{Deserialize, Serialize};
-use sqlx::SqlitePool;
-use ts_rs::TS;
-use utoipa;
-use uuid::Uuid;
-
-use crate::{
-    app_state::AppState,
-    executor::{
-        ActionType, ExecutorConfig, NormalizedConversation, NormalizedEntry, NormalizedEntryType,
-    },
-    middleware::{load_execution_process_with_context_middleware, load_task_attempt_middleware},
-    models::{
-        config::Config,
-        execution_process::{
-            ExecutionProcess, ExecutionProcessStatus, ExecutionProcessSummary, ExecutionProcessType,
-        },
-        project::Project,
-        task::{Task, TaskStatus},
-        task_attempt::{
-            BranchStatus, CreateFollowUpAttempt, CreatePrParams, CreateTaskAttempt, TaskAttempt,
-            TaskAttemptState, WorktreeDiff,
-        },
-        ApiResponse,
-    },
-};
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct RebaseTaskAttemptRequest {
-    pub new_base_branch: Option<String>,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct CreateGitHubPRRequest {
-    pub title: String,
-    pub body: Option<String>,
-    pub base_branch: Option<String>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct FollowUpResponse {
-    pub message: String,
-    pub actual_attempt_id: Uuid,
-    pub created_new_attempt: bool,
-}
-
-#[derive(Debug, Serialize, TS)]
-#[ts(export)]
-pub struct ProcessLogsResponse {
-    pub id: Uuid,
-    pub process_type: ExecutionProcessType,
-    pub command: String,
-    pub executor_type: Option<String>,
-    pub status: ExecutionProcessStatus,
-    pub normalized_conversation: NormalizedConversation,
-}
-
-// Helper to normalize logs for a process (extracted from get_execution_process_normalized_logs)
-async fn normalize_process_logs(
-    db_pool: &SqlitePool,
-    process: &ExecutionProcess,
-) -> NormalizedConversation {
-    use crate::models::{
-        execution_process::ExecutionProcessType, executor_session::ExecutorSession,
-    };
-    let executor_session = ExecutorSession::find_by_execution_process_id(db_pool, process.id)
-        .await
-        .ok()
-        .flatten();
-
-    let has_stdout = process
-        .stdout
-        .as_ref()
-        .map(|s| !s.trim().is_empty())
-        .unwrap_or(false);
-    let has_stderr = process
-        .stderr
-        .as_ref()
-        .map(|s| !s.trim().is_empty())
-        .unwrap_or(false);
-
-    if !has_stdout && !has_stderr {
-        return NormalizedConversation {
-            entries: vec![],
-            session_id: None,
-            executor_type: process
-                .executor_type
-                .clone()
-                .unwrap_or("unknown".to_string()),
-            prompt: executor_session.as_ref().and_then(|s| s.prompt.clone()),
-            summary: executor_session.as_ref().and_then(|s| s.summary.clone()),
-        };
-    }
-
-    // Parse stdout as JSONL using executor normalization
-    let mut stdout_entries = Vec::new();
-    if let Some(stdout) = &process.stdout {
-        if !stdout.trim().is_empty() {
-            let executor_type = process.executor_type.as_deref().unwrap_or("unknown");
-            let executor_config = if process.process_type == ExecutionProcessType::SetupScript {
-                ExecutorConfig::SetupScript {
-                    script: executor_session
-                        .as_ref()
-                        .and_then(|s| s.prompt.clone())
-                        .unwrap_or_else(|| "setup script".to_string()),
-                }
-            } else {
-                match executor_type.to_string().parse() {
-                    Ok(config) => config,
-                    Err(_) => {
-                        return NormalizedConversation {
-                            entries: vec![],
-                            session_id: None,
-                            executor_type: executor_type.to_string(),
-                            prompt: executor_session.as_ref().and_then(|s| s.prompt.clone()),
-                            summary: executor_session.as_ref().and_then(|s| s.summary.clone()),
-                        };
-                    }
-                }
-            };
-            let executor = executor_config.create_executor();
-            let working_dir_path = match std::fs::canonicalize(&process.working_directory) {
-                Ok(canonical_path) => canonical_path.to_string_lossy().to_string(),
-                Err(_) => process.working_directory.clone(),
-            };
-            if let Ok(normalized) = executor.normalize_logs(stdout, &working_dir_path) {
-                stdout_entries = normalized.entries;
-            }
-        }
-    }
-    // Parse stderr chunks separated by boundary markers
-    let mut stderr_entries = Vec::new();
-    if let Some(stderr) = &process.stderr {
-        let trimmed = stderr.trim();
-        if !trimmed.is_empty() {
-            let chunks: Vec<&str> = trimmed.split("---STDERR_CHUNK_BOUNDARY---").collect();
-            for chunk in chunks {
-                let chunk_trimmed = chunk.trim();
-                if !chunk_trimmed.is_empty() {
-                    let filtered_content = chunk_trimmed.replace("---STDERR_CHUNK_BOUNDARY---", "");
-                    if !filtered_content.trim().is_empty() {
-                        stderr_entries.push(NormalizedEntry {
-                            timestamp: Some(chrono::Utc::now().to_rfc3339()),
-                            entry_type: NormalizedEntryType::ErrorMessage,
-                            content: filtered_content.trim().to_string(),
-                            metadata: None,
-                        });
-                    }
-                }
-            }
-        }
-    }
-    let mut all_entries = Vec::new();
-    all_entries.extend(stdout_entries);
-    all_entries.extend(stderr_entries);
-    all_entries.sort_by(|a, b| match (&a.timestamp, &b.timestamp) {
-        (Some(a_ts), Some(b_ts)) => a_ts.cmp(b_ts),
-        (Some(_), None) => std::cmp::Ordering::Less,
-        (None, Some(_)) => std::cmp::Ordering::Greater,
-        (None, None) => std::cmp::Ordering::Equal,
-    });
-    let executor_type = if process.process_type == ExecutionProcessType::SetupScript {
-        "setup-script".to_string()
-    } else {
-        process
-            .executor_type
-            .clone()
-            .unwrap_or("unknown".to_string())
-    };
-    NormalizedConversation {
-        entries: all_entries,
-        session_id: None,
-        executor_type,
-        prompt: executor_session.as_ref().and_then(|s| s.prompt.clone()),
-        summary: executor_session.as_ref().and_then(|s| s.summary.clone()),
-    }
-}
-
-/// Get all normalized logs for all execution processes of a task attempt
-pub async fn get_task_attempt_all_logs(
-    Extension(_project): Extension<Project>,
-    Extension(_task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<Json<ApiResponse<Vec<ProcessLogsResponse>>>, StatusCode> {
-    // Fetch all execution processes for this attempt
-    let processes = match ExecutionProcess::find_by_task_attempt_id(
-        &app_state.db_pool,
-        task_attempt.id,
-    )
-    .await
-    {
-        Ok(list) => list,
-        Err(_) => return Err(StatusCode::INTERNAL_SERVER_ERROR),
-    };
-    // For each process, normalize logs
-    let mut result = Vec::new();
-    for process in processes {
-        let normalized_conversation = normalize_process_logs(&app_state.db_pool, &process).await;
-        result.push(ProcessLogsResponse {
-            id: process.id,
-            process_type: process.process_type.clone(),
-            command: process.command.clone(),
-            executor_type: process.executor_type.clone(),
-            status: process.status.clone(),
-            normalized_conversation,
-        });
-    }
-    Ok(Json(ApiResponse::success(result)))
-}
-
-#[utoipa::path(
-    get,
-    path = "/api/projects/{project_id}/tasks/{task_id}/attempts",
-    params(
-        ("project_id" = String, Path, description = "Project ID"),
-        ("task_id" = String, Path, description = "Task ID")
-    ),
-    responses(
-        (status = 200, description = "List all task attempts", body = ApiResponse<Vec<TaskAttempt>>),
-        (status = 404, description = "Project or task not found"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_attempts"
-)]
-pub async fn get_task_attempts(
-    Extension(_project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<Vec<TaskAttempt>>>, StatusCode> {
-    match TaskAttempt::find_by_task_id(&app_state.db_pool, task.id).await {
-        Ok(attempts) => Ok(ResponseJson(ApiResponse::success(attempts))),
-        Err(e) => {
-            tracing::error!("Failed to fetch task attempts for task {}: {}", task.id, e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-#[utoipa::path(
-    post,
-    path = "/api/projects/{project_id}/tasks/{task_id}/attempts",
-    params(
-        ("project_id" = String, Path, description = "Project ID"),
-        ("task_id" = String, Path, description = "Task ID")
-    ),
-    request_body = CreateTaskAttempt,
-    responses(
-        (status = 200, description = "Task attempt created successfully", body = ApiResponse<TaskAttempt>),
-        (status = 404, description = "Project or task not found"),
-        (status = 400, description = "Invalid input"),
-        (status = 500, description = "Internal server error")
-    ),
-    tag = "task_attempts"
-)]
-pub async fn create_task_attempt(
-    Extension(_project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    State(app_state): State<AppState>,
-    Json(payload): Json<CreateTaskAttempt>,
-) -> Result<ResponseJson<ApiResponse<TaskAttempt>>, StatusCode> {
-    let executor_string = payload.executor.as_ref().map(|exec| exec.to_string());
-
-    match TaskAttempt::create(&app_state.db_pool, &payload, task.id).await {
-        Ok(attempt) => {
-            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;
-            let task_id = task.id;
-            let project_id = _project.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(attempt)))
-        }
-        Err(e) => {
-            tracing::error!("Failed to create task attempt: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-pub async fn get_task_attempt_diff(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<WorktreeDiff>>, StatusCode> {
-    match TaskAttempt::get_diff(&app_state.db_pool, task_attempt.id, task.id, project.id).await {
-        Ok(diff) => Ok(ResponseJson(ApiResponse::success(diff))),
-        Err(e) => {
-            tracing::error!(
-                "Failed to get diff for task attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-#[axum::debug_handler]
-pub async fn merge_task_attempt(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    match TaskAttempt::merge_changes(&app_state.db_pool, task_attempt.id, task.id, project.id).await
-    {
-        Ok(_) => {
-            // Update task status to Done
-            if let Err(e) = Task::update_status(
-                &app_state.db_pool,
-                task.id,
-                project.id,
-                crate::models::task::TaskStatus::Done,
-            )
-            .await
-            {
-                tracing::error!("Failed to update task status to Done after merge: {}", e);
-                return Err(StatusCode::INTERNAL_SERVER_ERROR);
-            }
-
-            // Track task attempt merged event
-            app_state
-                .track_analytics_event(
-                    "task_attempt_merged",
-                    Some(serde_json::json!({
-                        "task_id": task.id.to_string(),
-                        "project_id": project.id.to_string(),
-                        "attempt_id": task_attempt.id.to_string(),
-                    })),
-                )
-                .await;
-
-            Ok(ResponseJson(ApiResponse::success(())))
-        }
-        Err(e) => {
-            tracing::error!("Failed to merge task attempt {}: {}", task_attempt.id, e);
-            Ok(ResponseJson(ApiResponse::error(&format!(
-                "Failed to merge: {}",
-                e
-            ))))
-        }
-    }
-}
-
-pub async fn create_github_pr(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-    Json(request): Json<CreateGitHubPRRequest>,
-) -> Result<ResponseJson<ApiResponse<String>>, StatusCode> {
-    // Load the user's GitHub configuration
-    let config = match Config::load(&crate::utils::config_path()) {
-        Ok(config) => config,
-        Err(e) => {
-            tracing::error!("Failed to load config: {}", e);
-            return Err(StatusCode::INTERNAL_SERVER_ERROR);
-        }
-    };
-
-    let github_token = match config.github.token {
-        Some(token) => token,
-        None => {
-            return Ok(ResponseJson(ApiResponse::error(
-                "GitHub authentication not configured. Please sign in with GitHub.",
-            )));
-        }
-    };
-
-    // Get the task attempt to access the stored base branch
-    let attempt = &task_attempt;
-
-    let base_branch = request.base_branch.unwrap_or_else(|| {
-        // Use the stored base branch from the task attempt as the default
-        // Fall back to config default or "main" only if stored base branch is somehow invalid
-        if !attempt.base_branch.trim().is_empty() {
-            attempt.base_branch.clone()
-        } else {
-            config
-                .github
-                .default_pr_base
-                .unwrap_or_else(|| "main".to_string())
-        }
-    });
-
-    match TaskAttempt::create_github_pr(
-        &app_state.db_pool,
-        CreatePrParams {
-            attempt_id: task_attempt.id,
-            task_id: task.id,
-            project_id: project.id,
-            github_token: &config.github.pat.unwrap_or(github_token),
-            title: &request.title,
-            body: request.body.as_deref(),
-            base_branch: Some(&base_branch),
-        },
-    )
-    .await
-    {
-        Ok(pr_url) => {
-            app_state
-                .track_analytics_event(
-                    "github_pr_created",
-                    Some(serde_json::json!({
-                        "task_id": task.id.to_string(),
-                        "project_id": project.id.to_string(),
-                        "attempt_id": task_attempt.id.to_string(),
-                    })),
-                )
-                .await;
-
-            Ok(ResponseJson(ApiResponse::success(pr_url)))
-        }
-        Err(e) => {
-            tracing::error!(
-                "Failed to create GitHub PR for attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            let message = match &e {
-                crate::models::task_attempt::TaskAttemptError::GitHubService(
-                    crate::services::GitHubServiceError::TokenInvalid,
-                ) => Some("github_token_invalid".to_string()),
-                crate::models::task_attempt::TaskAttemptError::GitService(
-                    crate::services::git_service::GitServiceError::Git(err),
-                ) if err
-                    .message()
-                    .contains("too many redirects or authentication replays") =>
-                {
-                    Some("insufficient_github_permissions".to_string()) // PAT is invalid
-                }
-                crate::models::task_attempt::TaskAttemptError::GitService(
-                    crate::services::git_service::GitServiceError::Git(err),
-                ) if err.message().contains("status code: 403") => {
-                    Some("insufficient_github_permissions".to_string())
-                }
-                crate::models::task_attempt::TaskAttemptError::GitService(
-                    crate::services::git_service::GitServiceError::Git(err),
-                ) if err.message().contains("status code: 404") => {
-                    Some("github_repo_not_found_or_no_access".to_string())
-                }
-                _ => Some(format!("Failed to create PR: {}", e)),
-            };
-            Ok(ResponseJson(ApiResponse::error(
-                message.as_deref().unwrap_or("Unknown error"),
-            )))
-        }
-    }
-}
-
-#[derive(serde::Deserialize)]
-pub struct OpenEditorRequest {
-    editor_type: Option<String>,
-}
-
-pub async fn open_task_attempt_in_editor(
-    Extension(_project): Extension<Project>,
-    Extension(_task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-    Json(payload): Json<Option<OpenEditorRequest>>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    // Get the task attempt to access the worktree path
-    let attempt = &task_attempt;
-
-    // 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 worktree directory
-    let mut cmd = std::process::Command::new(&editor_command[0]);
-    for arg in &editor_command[1..] {
-        cmd.arg(arg);
-    }
-    cmd.arg(&attempt.worktree_path);
-
-    match cmd.spawn() {
-        Ok(_) => {
-            tracing::info!(
-                "Opened editor ({}) for task attempt {} at path: {}",
-                editor_command.join(" "),
-                task_attempt.id,
-                attempt.worktree_path
-            );
-            Ok(ResponseJson(ApiResponse::success(())))
-        }
-        Err(e) => {
-            tracing::error!(
-                "Failed to open editor ({}) for attempt {}: {}",
-                editor_command.join(" "),
-                task_attempt.id,
-                e
-            );
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-pub async fn get_task_attempt_branch_status(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<BranchStatus>>, StatusCode> {
-    match TaskAttempt::get_branch_status(&app_state.db_pool, task_attempt.id, task.id, project.id)
-        .await
-    {
-        Ok(status) => Ok(ResponseJson(ApiResponse::success(status))),
-        Err(e) => {
-            tracing::error!(
-                "Failed to get branch status for task attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-#[axum::debug_handler]
-pub async fn rebase_task_attempt(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-    request_body: Option<Json<RebaseTaskAttemptRequest>>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    // Extract new base branch from request body if provided
-    let new_base_branch = request_body.and_then(|body| body.new_base_branch.clone());
-
-    match TaskAttempt::rebase_attempt(
-        &app_state.db_pool,
-        task_attempt.id,
-        task.id,
-        project.id,
-        new_base_branch,
-    )
-    .await
-    {
-        Ok(_new_base_commit) => Ok(ResponseJson(ApiResponse::success(()))),
-        Err(e) => {
-            tracing::error!("Failed to rebase task attempt {}: {}", task_attempt.id, e);
-            Ok(ResponseJson(ApiResponse::error(&e.to_string())))
-        }
-    }
-}
-
-pub async fn get_task_attempt_execution_processes(
-    Extension(_project): Extension<Project>,
-    Extension(_task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<Vec<ExecutionProcessSummary>>>, StatusCode> {
-    match ExecutionProcess::find_summaries_by_task_attempt_id(&app_state.db_pool, task_attempt.id)
-        .await
-    {
-        Ok(processes) => Ok(ResponseJson(ApiResponse::success(processes))),
-        Err(e) => {
-            tracing::error!(
-                "Failed to fetch execution processes for attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-pub async fn get_execution_process(
-    Extension(execution_process): Extension<ExecutionProcess>,
-) -> Result<ResponseJson<ApiResponse<ExecutionProcess>>, StatusCode> {
-    Ok(ResponseJson(ApiResponse::success(execution_process)))
-}
-
-#[axum::debug_handler]
-pub async fn stop_all_execution_processes(
-    Extension(_project): Extension<Project>,
-    Extension(_task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    // Get all execution processes for the task attempt
-    let processes = match ExecutionProcess::find_by_task_attempt_id(
-        &app_state.db_pool,
-        task_attempt.id,
-    )
-    .await
-    {
-        Ok(processes) => processes,
-        Err(e) => {
-            tracing::error!(
-                "Failed to fetch execution processes for attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            return Err(StatusCode::INTERNAL_SERVER_ERROR);
-        }
-    };
-
-    let mut stopped_count = 0;
-    let mut errors = Vec::new();
-
-    // Stop all running processes
-    for process in processes {
-        match app_state.stop_running_execution_by_id(process.id).await {
-            Ok(true) => {
-                stopped_count += 1;
-
-                // Update the execution process status in the database
-                if let Err(e) = ExecutionProcess::update_completion(
-                    &app_state.db_pool,
-                    process.id,
-                    crate::models::execution_process::ExecutionProcessStatus::Killed,
-                    None,
-                )
-                .await
-                {
-                    tracing::error!("Failed to update execution process status: {}", e);
-                    errors.push(format!("Failed to update process {} status", process.id));
-                } else {
-                    // Process stopped successfully
-                }
-            }
-            Ok(false) => {
-                // Process was not running, which is fine
-            }
-            Err(e) => {
-                tracing::error!("Failed to stop execution process {}: {}", process.id, e);
-                errors.push(format!("Failed to stop process {}: {}", process.id, e));
-            }
-        }
-    }
-
-    if !errors.is_empty() {
-        return Ok(ResponseJson(ApiResponse::error(&format!(
-            "Stopped {} processes, but encountered errors: {}",
-            stopped_count,
-            errors.join(", ")
-        ))));
-    }
-
-    if stopped_count == 0 {
-        return Ok(ResponseJson(ApiResponse::success(())));
-    }
-
-    Ok(ResponseJson(ApiResponse::success(())))
-}
-
-#[axum::debug_handler]
-pub async fn stop_execution_process(
-    Extension(_project): Extension<Project>,
-    Extension(_task): Extension<Task>,
-    Extension(_task_attempt): Extension<TaskAttempt>,
-    Extension(execution_process): Extension<ExecutionProcess>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    // Stop the specific execution process
-    let stopped = match app_state
-        .stop_running_execution_by_id(execution_process.id)
-        .await
-    {
-        Ok(stopped) => stopped,
-        Err(e) => {
-            tracing::error!(
-                "Failed to stop execution process {}: {}",
-                execution_process.id,
-                e
-            );
-            return Err(StatusCode::INTERNAL_SERVER_ERROR);
-        }
-    };
-
-    if !stopped {
-        return Ok(ResponseJson(ApiResponse::success(())));
-    }
-
-    // Update the execution process status in the database
-    if let Err(e) = ExecutionProcess::update_completion(
-        &app_state.db_pool,
-        execution_process.id,
-        crate::models::execution_process::ExecutionProcessStatus::Killed,
-        None,
-    )
-    .await
-    {
-        tracing::error!("Failed to update execution process status: {}", e);
-        return Err(StatusCode::INTERNAL_SERVER_ERROR);
-    }
-
-    // Process stopped successfully
-
-    Ok(ResponseJson(ApiResponse::success(())))
-}
-
-#[derive(serde::Deserialize)]
-pub struct DeleteFileQuery {
-    file_path: String,
-}
-
-#[axum::debug_handler]
-pub async fn delete_task_attempt_file(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    Query(query): Query<DeleteFileQuery>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    match TaskAttempt::delete_file(
-        &app_state.db_pool,
-        task_attempt.id,
-        task.id,
-        project.id,
-        &query.file_path,
-    )
-    .await
-    {
-        Ok(_commit_id) => Ok(ResponseJson(ApiResponse::success(()))),
-        Err(e) => {
-            tracing::error!(
-                "Failed to delete file '{}' from task attempt {}: {}",
-                query.file_path,
-                task_attempt.id,
-                e
-            );
-            Ok(ResponseJson(ApiResponse::error(&e.to_string())))
-        }
-    }
-}
-
-pub async fn create_followup_attempt(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-    Json(payload): Json<CreateFollowUpAttempt>,
-) -> Result<ResponseJson<ApiResponse<FollowUpResponse>>, StatusCode> {
-    // Start follow-up execution synchronously to catch errors
-    match TaskAttempt::start_followup_execution(
-        &app_state.db_pool,
-        &app_state,
-        task_attempt.id,
-        task.id,
-        project.id,
-        &payload.prompt,
-    )
-    .await
-    {
-        Ok(actual_attempt_id) => {
-            let created_new_attempt = actual_attempt_id != task_attempt.id;
-            let message = if created_new_attempt {
-                format!(
-                    "Follow-up execution started on new attempt {} (original worktree was deleted)",
-                    actual_attempt_id
-                )
-            } else {
-                "Follow-up execution started successfully".to_string()
-            };
-
-            Ok(ResponseJson(ApiResponse::success(FollowUpResponse {
-                message: message.clone(),
-                actual_attempt_id,
-                created_new_attempt,
-            })))
-        }
-        Err(e) => {
-            tracing::error!(
-                "Failed to start follow-up execution for task attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-pub async fn start_dev_server(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<()>>, StatusCode> {
-    // Stop any existing dev servers for this project
-    let existing_dev_servers =
-        match ExecutionProcess::find_running_dev_servers_by_project(&app_state.db_pool, project.id)
-            .await
-        {
-            Ok(servers) => servers,
-            Err(e) => {
-                tracing::error!(
-                    "Failed to find running dev servers for project {}: {}",
-                    project.id,
-                    e
-                );
-                return Err(StatusCode::INTERNAL_SERVER_ERROR);
-            }
-        };
-
-    for dev_server in existing_dev_servers {
-        tracing::info!(
-            "Stopping existing dev server {} for project {}",
-            dev_server.id,
-            project.id
-        );
-
-        // Stop the running process
-        if let Err(e) = app_state.stop_running_execution_by_id(dev_server.id).await {
-            tracing::error!("Failed to stop dev server {}: {}", dev_server.id, e);
-        } else {
-            // Update the execution process status in the database
-            if let Err(e) = ExecutionProcess::update_completion(
-                &app_state.db_pool,
-                dev_server.id,
-                crate::models::execution_process::ExecutionProcessStatus::Killed,
-                None,
-            )
-            .await
-            {
-                tracing::error!(
-                    "Failed to update dev server {} status: {}",
-                    dev_server.id,
-                    e
-                );
-            }
-        }
-    }
-
-    // Start dev server execution
-    match TaskAttempt::start_dev_server(
-        &app_state.db_pool,
-        &app_state,
-        task_attempt.id,
-        task.id,
-        project.id,
-    )
-    .await
-    {
-        Ok(_) => Ok(ResponseJson(ApiResponse::success(()))),
-        Err(e) => {
-            tracing::error!(
-                "Failed to start dev server for task attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            Ok(ResponseJson(ApiResponse::error(&e.to_string())))
-        }
-    }
-}
-
-pub async fn get_task_attempt_execution_state(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<TaskAttemptState>>, StatusCode> {
-    // Get the execution state
-    match TaskAttempt::get_execution_state(&app_state.db_pool, task_attempt.id, task.id, project.id)
-        .await
-    {
-        Ok(state) => Ok(ResponseJson(ApiResponse::success(state))),
-        Err(e) => {
-            tracing::error!(
-                "Failed to get execution state for task attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-/// Find plan content with context by searching through multiple processes in the same attempt
-async fn find_plan_content_with_context(
-    pool: &SqlitePool,
-    attempt_id: Uuid,
-) -> Result<String, StatusCode> {
-    // Get all execution processes for this attempt
-    let execution_processes =
-        match ExecutionProcess::find_by_task_attempt_id(pool, attempt_id).await {
-            Ok(processes) => processes,
-            Err(e) => {
-                tracing::error!(
-                    "Failed to fetch execution processes for attempt {}: {}",
-                    attempt_id,
-                    e
-                );
-                return Err(StatusCode::INTERNAL_SERVER_ERROR);
-            }
-        };
-
-    // Look for claudeplan processes (most recent first)
-    for claudeplan_process in execution_processes
-        .iter()
-        .rev()
-        .filter(|p| p.executor_type.as_deref() == Some("claude-plan"))
-    {
-        if let Some(stdout) = &claudeplan_process.stdout {
-            if !stdout.trim().is_empty() {
-                // Create executor and normalize logs
-                let executor_config = ExecutorConfig::ClaudePlan;
-                let executor = executor_config.create_executor();
-
-                // Use working directory for normalization
-                let working_dir_path =
-                    match std::fs::canonicalize(&claudeplan_process.working_directory) {
-                        Ok(canonical_path) => canonical_path.to_string_lossy().to_string(),
-                        Err(_) => claudeplan_process.working_directory.clone(),
-                    };
-
-                // Normalize logs and extract plan content
-                match executor.normalize_logs(stdout, &working_dir_path) {
-                    Ok(normalized_conversation) => {
-                        // Search for plan content in the normalized conversation
-                        if let Some(plan_content) = normalized_conversation
-                            .entries
-                            .iter()
-                            .rev()
-                            .find_map(|entry| {
-                                if let NormalizedEntryType::ToolUse {
-                                    action_type: ActionType::PlanPresentation { plan },
-                                    ..
-                                } = &entry.entry_type
-                                {
-                                    Some(plan.clone())
-                                } else {
-                                    None
-                                }
-                            })
-                        {
-                            return Ok(plan_content);
-                        }
-                    }
-                    Err(_) => {
-                        continue;
-                    }
-                }
-            }
-        }
-    }
-
-    tracing::error!(
-        "No claudeplan content found in any process in attempt {}",
-        attempt_id
-    );
-    Err(StatusCode::NOT_FOUND)
-}
-
-pub async fn approve_plan(
-    Extension(project): Extension<Project>,
-    Extension(task): Extension<Task>,
-    Extension(task_attempt): Extension<TaskAttempt>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<FollowUpResponse>>, StatusCode> {
-    let current_task = &task;
-
-    // Find plan content with context across the task hierarchy
-    let plan_content = find_plan_content_with_context(&app_state.db_pool, task_attempt.id).await?;
-
-    use crate::models::task::CreateTask;
-    let new_task_id = Uuid::new_v4();
-    let create_task_data = CreateTask {
-        project_id: project.id,
-        title: format!("Execute Plan: {}", current_task.title),
-        description: Some(plan_content),
-        wish_id: current_task.wish_id.clone(),
-        parent_task_attempt: Some(task_attempt.id),
-    };
-
-    let new_task = match Task::create(&app_state.db_pool, &create_task_data, new_task_id).await {
-        Ok(task) => task,
-        Err(e) => {
-            tracing::error!("Failed to create new task: {}", e);
-            return Err(StatusCode::INTERNAL_SERVER_ERROR);
-        }
-    };
-
-    // Mark original task as completed since it now has children
-    if let Err(e) =
-        Task::update_status(&app_state.db_pool, task.id, project.id, TaskStatus::Done).await
-    {
-        tracing::error!("Failed to update original task status to Done: {}", e);
-        return Err(StatusCode::INTERNAL_SERVER_ERROR);
-    } else {
-        tracing::info!(
-            "Original task {} marked as Done after plan approval (has children)",
-            task.id
-        );
-    }
-
-    Ok(ResponseJson(ApiResponse::success(FollowUpResponse {
-        message: format!("Plan approved and new task created: {}", new_task.title),
-        actual_attempt_id: new_task_id, // Return the new task ID
-        created_new_attempt: true,
-    })))
-}
-
-pub async fn get_task_attempt_details(
-    Extension(task_attempt): Extension<TaskAttempt>,
-) -> Result<ResponseJson<ApiResponse<TaskAttempt>>, StatusCode> {
-    Ok(ResponseJson(ApiResponse::success(task_attempt)))
-}
-
-pub async fn get_task_attempt_children(
-    Extension(task_attempt): Extension<TaskAttempt>,
-    Extension(project): Extension<Project>,
-    State(app_state): State<AppState>,
-) -> Result<ResponseJson<ApiResponse<Vec<Task>>>, StatusCode> {
-    match Task::find_related_tasks_by_attempt_id(&app_state.db_pool, task_attempt.id, project.id)
-        .await
-    {
-        Ok(related_tasks) => Ok(ResponseJson(ApiResponse::success(related_tasks))),
-        Err(e) => {
-            tracing::error!(
-                "Failed to fetch children for task attempt {}: {}",
-                task_attempt.id,
-                e
-            );
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-pub fn task_attempts_list_router(_state: AppState) -> Router<AppState> {
-    Router::new().route(
-        "/projects/:project_id/tasks/:task_id/attempts",
-        get(get_task_attempts).post(create_task_attempt),
-    )
-}
-
-pub fn task_attempts_with_id_router(_state: AppState) -> Router<AppState> {
-    use axum::routing::post;
-
-    Router::new()
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/diff",
-            get(get_task_attempt_diff),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/merge",
-            post(merge_task_attempt),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/branch-status",
-            get(get_task_attempt_branch_status),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/rebase",
-            post(rebase_task_attempt),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/open-editor",
-            post(open_task_attempt_in_editor),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/delete-file",
-            post(delete_task_attempt_file),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/create-pr",
-            post(create_github_pr),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/execution-processes",
-            get(get_task_attempt_execution_processes),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/stop",
-            post(stop_all_execution_processes),
-        )
-        .merge(
-            Router::new()
-                .route(
-                    "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/execution-processes/:process_id/stop",
-                    post(stop_execution_process),
-                )
-                .route_layer(from_fn_with_state(_state.clone(), load_execution_process_with_context_middleware))
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/logs",
-            get(get_task_attempt_all_logs),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/follow-up",
-            post(create_followup_attempt),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/start-dev-server",
-            post(start_dev_server),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id",
-            get(get_task_attempt_execution_state),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/approve-plan",
-            post(approve_plan),
-        )
-        .route(
-            "/projects/:project_id/tasks/:task_id/attempts/:attempt_id/children",
-            get(get_task_attempt_children),
-        )
-        .merge(
-            Router::new()
-                .route(
-                    "/attempts/:attempt_id/details",
-                    get(get_task_attempt_details),
-                )
-                .route_layer(from_fn_with_state(_state.clone(), load_task_attempt_middleware))
-        )
-}