codebridge_cli/

handlers.rs

use crate::actions::execute_action;
use crate::build::run_build;
use crate::build_detector;
use crate::config::AppConfig;
use crate::error::{AppError, AppResult};
use crate::models::*;
use crate::security::safe_join;
use axum::Json;
use axum::extract::{Query, State};
use std::sync::Arc;
use tokio::fs;
use tokio::process::Command;
use tracing::{debug, info, warn};
use uuid::Uuid;

pub async fn ping() -> &'static str {
    "pong"
}
pub async fn open_editor(Json(req): Json<OpenEditorRequest>) -> AppResult<Json<serde_json::Value>> {
    info!("Opening editor '{}' for path: {}", req.editor, req.path);

    let mut arg = req.path;
    if let Some(line) = req.line {
        arg.push_str(&format!(":{}", line));
        if let Some(col) = req.column {
            arg.push_str(&format!(":{}", col));
        }
    }

    tokio::task::spawn_blocking(move || {
        Command::new(&req.editor)
            .arg(&arg)
            .spawn()
            .map_err(|e| AppError::Internal(format!("Failed to launch editor: {}", e)))
    })
    .await
    .map_err(|e| AppError::Internal(format!("Task error: {}", e)))??;

    Ok(Json(serde_json::json!({ "success": true })))
}
pub async fn execute(
    State(config): State<Arc<AppConfig>>,
    Json(req): Json<ExecuteRequest>,
) -> AppResult<Json<ExecuteResponse>> {
    let request_id = Uuid::new_v4();
    info!(
        request_id = %request_id,
        project_id = %req.project_id,
        action_count = req.actions.len(),
        "Execute request received"
    );

    let project_root = config.workspace.join(&req.project_id);
    if !project_root.exists() {
        warn!(
            request_id = %request_id,
            project_id = %req.project_id,
            "Project directory does not exist"
        );
        return Err(AppError::BadRequest(format!(
            "Project '{}' does not exist",
            req.project_id
        )));
    }

    // Execute actions
    let mut action_results = Vec::new();
    let mut any_failed = false;
    for (idx, action) in req.actions.into_iter().enumerate() {
        debug!(
            request_id = %request_id,
            action_index = idx,
            action_type = ?action,
            "Executing action"
        );
        // Pass config to actions (for script execution)
        match execute_action(action, &project_root, &config).await {
            Ok(result) => {
                if result.success {
                    info!(
                        request_id = %request_id,
                        action_index = idx,
                        "Action succeeded"
                    );
                } else {
                    warn!(
                        request_id = %request_id,
                        action_index = idx,
                        error = ?result.error,
                        "Action failed"
                    );
                    any_failed = true;
                }
                action_results.push(result);
            }
            Err(e) => {
                warn!(
                    request_id = %request_id,
                    action_index = idx,
                    error = ?e,
                    "Action execution error"
                );
                any_failed = true;
                action_results.push(ActionResult {
                    success: false,
                    path: None,
                    content: None,
                    error: Some(e.to_string()),
                });
            }
        }
    }

    // Decide whether to run build (smart detection)
    let (build_output, continue_loop) = if any_failed {
        info!(
            request_id = %request_id,
            "Skipping build due to action failure"
        );
        (None, false)
    } else {
        // Determine build command using smart detection
        let build_cmd = build_detector::get_build_command(&project_root, &config.build_command);
        if let Some(cmd) = build_cmd {
            info!(
                request_id = %request_id,
                build_command = %cmd,
                "Running build"
            );
            let build_output = run_build(&project_root, &cmd).await;
            let continue_loop = !build_output.success;
            (Some(build_output), continue_loop)
        } else {
            info!(
                request_id = %request_id,
                "No build command needed for this project"
            );
            (None, false)
        }
    };

    let response = ExecuteResponse {
        action_results,
        build_output,
        continue_loop,
    };

    info!(
        request_id = %request_id,
        continue_loop = continue_loop,
        "Sending response"
    );

    Ok(Json(response))
}

// NEW: GET /worktrees?projectId=<id> endpoint
pub async fn list_worktrees(
    State(config): State<Arc<AppConfig>>,
    Query(query): Query<ListFilesQuery>,
) -> AppResult<Json<Vec<WorktreeInfo>>> {
    info!("Listing worktrees for project: {}", query.project_id);

    let project_root = config.workspace.join(&query.project_id);
    if !project_root.exists() {
        return Err(AppError::NotFound(format!(
            "Project '{}' not found",
            query.project_id
        )));
    }

    // Execute git worktree list action
    let action = Action::GitWorktreeList;
    match execute_action(action, &project_root, &config).await {
        Ok(result) => {
            if result.success {
                if let Some(content) = result.content {
                    let worktrees: Vec<WorktreeInfo> =
                        serde_json::from_str(&content).map_err(|e| {
                            AppError::Internal(format!("Failed to parse worktrees: {}", e))
                        })?;
                    Ok(Json(worktrees))
                } else {
                    Ok(Json(Vec::new()))
                }
            } else {
                Err(AppError::Internal(
                    result
                        .error
                        .unwrap_or_else(|| "Failed to list worktrees".to_string()),
                ))
            }
        }
        Err(e) => Err(e),
    }
}
/// GET /projects – list all project directories under workspace
pub async fn list_projects(State(config): State<Arc<AppConfig>>) -> AppResult<Json<Vec<String>>> {
    info!("Listing projects in workspace: {:?}", config.workspace);
    let mut projects = Vec::new();
    let mut read_dir = fs::read_dir(&config.workspace)
        .await
        .map_err(|e| AppError::Internal(format!("Failed to read workspace: {}", e)))?;

    while let Ok(Some(entry)) = read_dir.next_entry().await {
        if entry
            .file_type()
            .await
            .map(|ft| ft.is_dir())
            .unwrap_or(false)
            && let Ok(name) = entry.file_name().into_string()
        {
            projects.push(name);
        }
    }
    info!("Found {} projects", projects.len());
    Ok(Json(projects))
}

/// GET /list-files?projectId=<id> – recursive file listing for a project, respecting .gitignore
pub async fn list_files(
    State(config): State<Arc<AppConfig>>,
    Query(query): Query<ListFilesQuery>,
) -> AppResult<Json<Vec<FileEntry>>> {
    info!(
        "Listing files for project: {} in workspace: {:?}",
        query.project_id, config.workspace
    );
    let project_path = config.workspace.join(&query.project_id);
    if !project_path.exists() {
        warn!("Project '{}' not found", query.project_id);
        return Err(AppError::NotFound(format!(
            "Project '{}' not found",
            query.project_id
        )));
    }

    let mut entries = Vec::new();

    // Use ignore::WalkBuilder to respect .gitignore and skip hidden files
    let walker = ignore::WalkBuilder::new(&project_path)
        .hidden(true) // skip hidden files (those starting with '.')
        .git_ignore(true) // respect .gitignore
        .build();

    for result in walker {
        let entry = match result {
            Ok(e) => e,
            Err(e) => {
                warn!("Failed to read entry: {}", e);
                continue; // skip problematic entries, but continue walking
            }
        };

        // Skip the root directory itself
        if entry.path() == project_path {
            continue;
        }

        let metadata = match entry.metadata() {
            Ok(m) => m,
            Err(e) => {
                warn!("Failed to get metadata for {:?}: {}", entry.path(), e);
                continue;
            }
        };

        let relative_path = match entry.path().strip_prefix(&project_path) {
            Ok(p) => p,
            Err(e) => {
                warn!("Failed to strip prefix for {:?}: {}", entry.path(), e);
                continue;
            }
        };
        let path_str = relative_path.to_string_lossy().to_string();
        let name = entry.file_name().to_string_lossy().to_string();

        entries.push(FileEntry {
            name,
            path: path_str,
            is_dir: metadata.is_dir(),
            size: if metadata.is_file() {
                Some(metadata.len())
            } else {
                None
            },
        });
    }

    info!(
        "Found {} files in project {}",
        entries.len(),
        query.project_id
    );
    Ok(Json(entries))
}
/// GET /file-content?projectId=<id>&path=<path> – return file content as plain text
pub async fn file_content(
    State(config): State<Arc<AppConfig>>,
    Query(query): Query<FileContentQuery>,
) -> AppResult<String> {
    info!(
        "Getting file content for project: {}, path: {}",
        query.project_id, query.path
    );
    let project_path = config.workspace.join(&query.project_id);
    let full_path = safe_join(&project_path, &query.path)?;

    if !full_path.exists() {
        warn!("File not found: {}", query.path);
        return Err(AppError::NotFound(format!(
            "File not found: {}",
            query.path
        )));
    }
    if full_path.is_dir() {
        warn!("Path is a directory: {}", query.path);
        return Err(AppError::BadRequest("Path is a directory".into()));
    }

    let content = fs::read_to_string(&full_path)
        .await
        .map_err(|e| AppError::Internal(format!("Failed to read file: {}", e)))?;
    info!("Successfully read file: {}", query.path);
    Ok(content)
}