tsk/

task.rs

use crate::assets::{AssetManager, layered::LayeredAssetManager};
use crate::context::AppContext;
use crate::git::RepoManager;
use chrono::{DateTime, Local, Utc};
use serde::{Deserialize, Serialize};
use std::error::Error;
use std::path::{Path, PathBuf};

/// Represents the execution status of a task
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum TaskStatus {
    /// Task is in the queue waiting to be executed
    #[serde(rename = "QUEUED")]
    Queued,
    /// Task is currently being executed
    #[serde(rename = "RUNNING")]
    Running,
    /// Task execution failed
    #[serde(rename = "FAILED")]
    Failed,
    /// Task completed successfully
    #[serde(rename = "COMPLETE")]
    Complete,
}

/// Represents a TSK task with all required fields for execution
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Task {
    /// Unique identifier for the task (format: YYYY-MM-DD-HHMM-{task_type}-{name})
    pub id: String,
    /// Absolute path to the repository root where the task was created
    pub repo_root: PathBuf,
    /// Human-readable name for the task
    pub name: String,
    /// Type of task (e.g., "feat", "fix", "refactor")
    pub task_type: String,
    /// Path to the instructions file containing task details
    pub instructions_file: String,
    /// AI agent to use for task execution (e.g., "claude-code")
    pub agent: String,
    /// Timeout in minutes for task execution
    pub timeout: u32,
    /// Current status of the task
    pub status: TaskStatus,
    /// When the task was created
    pub created_at: DateTime<Local>,
    /// When the task started execution (if started)
    pub started_at: Option<DateTime<Utc>>,
    /// When the task completed (if completed)
    pub completed_at: Option<DateTime<Utc>>,
    /// Git branch name for this task (format: tsk/{task-id})
    pub branch_name: String,
    /// Error message if task failed
    pub error_message: Option<String>,
    /// Git commit SHA from which the task was created
    pub source_commit: String,
    /// Technology stack for Docker image selection (e.g., "rust", "python", "default")
    pub tech_stack: String,
    /// Project name for Docker image selection (defaults to "default")
    pub project: String,
    /// Path to the copied repository for this task
    pub copied_repo_path: PathBuf,
}

impl Task {
    /// Creates a new Task with all required fields
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        id: String,
        repo_root: PathBuf,
        name: String,
        task_type: String,
        instructions_file: String,
        agent: String,
        timeout: u32,
        branch_name: String,
        source_commit: String,
        tech_stack: String,
        project: String,
        created_at: DateTime<Local>,
        copied_repo_path: PathBuf,
    ) -> Self {
        Self {
            id,
            repo_root,
            name,
            task_type,
            instructions_file,
            agent,
            timeout,
            status: TaskStatus::Queued,
            created_at,
            started_at: None,
            completed_at: None,
            branch_name,
            error_message: None,
            source_commit,
            tech_stack,
            project,
            copied_repo_path,
        }
    }
}

/// Builder for creating tasks with a fluent API
pub struct TaskBuilder {
    repo_root: Option<PathBuf>,
    name: Option<String>,
    task_type: Option<String>,
    description: Option<String>,
    /// Path to a file containing instructions
    instructions_file_path: Option<PathBuf>,
    edit: bool,
    agent: Option<String>,
    timeout: Option<u32>,
    tech_stack: Option<String>,
    project: Option<String>,
    copied_repo_path: Option<PathBuf>,
}

impl TaskBuilder {
    pub fn new() -> Self {
        Self {
            repo_root: None,
            name: None,
            task_type: None,
            description: None,
            instructions_file_path: None,
            edit: false,
            agent: None,
            timeout: None,
            tech_stack: None,
            project: None,
            copied_repo_path: None,
        }
    }

    /// Creates a TaskBuilder from an existing task. This is used for retrying tasks.
    pub fn from_existing(task: &Task) -> Self {
        let mut builder = Self::new();
        builder.repo_root = Some(task.repo_root.clone());
        builder.name = Some(task.name.clone());
        builder.task_type = Some(task.task_type.clone());
        builder.agent = Some(task.agent.clone());
        builder.timeout = Some(task.timeout);
        builder.tech_stack = Some(task.tech_stack.clone());
        builder.project = Some(task.project.clone());
        builder.copied_repo_path = Some(task.copied_repo_path.clone());

        // Copy the instructions file path
        builder.instructions_file_path = Some(PathBuf::from(&task.instructions_file));

        builder
    }

    pub fn repo_root(mut self, repo_root: PathBuf) -> Self {
        self.repo_root = Some(repo_root);
        self
    }

    pub fn name(mut self, name: String) -> Self {
        self.name = Some(name);
        self
    }

    pub fn task_type(mut self, task_type: String) -> Self {
        self.task_type = Some(task_type);
        self
    }

    pub fn description(mut self, description: Option<String>) -> Self {
        self.description = description;
        self
    }

    /// Sets the path to a file containing instructions
    pub fn instructions_file(mut self, path: Option<PathBuf>) -> Self {
        self.instructions_file_path = path;
        self
    }

    pub fn edit(mut self, edit: bool) -> Self {
        self.edit = edit;
        self
    }

    pub fn agent(mut self, agent: Option<String>) -> Self {
        self.agent = agent;
        self
    }

    pub fn timeout(mut self, timeout: u32) -> Self {
        self.timeout = Some(timeout);
        self
    }

    pub fn tech_stack(mut self, tech_stack: Option<String>) -> Self {
        self.tech_stack = tech_stack;
        self
    }

    pub fn project(mut self, project: Option<String>) -> Self {
        self.project = project;
        self
    }

    pub async fn build(self, ctx: &AppContext) -> Result<Task, Box<dyn Error>> {
        let repo_root = self
            .repo_root
            .clone()
            .ok_or("Repository root is required")?;
        let name = self.name.clone().ok_or("Task name is required")?;
        let task_type = self
            .task_type
            .clone()
            .unwrap_or_else(|| "generic".to_string());
        let timeout = self.timeout.unwrap_or(30);

        // Validate input
        if self.description.is_none() && self.instructions_file_path.is_none() && !self.edit {
            return Err(
                "Either description or instructions file must be provided, or use edit mode".into(),
            );
        }

        // Get agent or use default
        let agent = self
            .agent
            .clone()
            .unwrap_or_else(|| crate::agent::AgentProvider::default_agent().to_string());

        // Validate agent
        if !crate::agent::AgentProvider::is_valid_agent(&agent) {
            let available_agents = crate::agent::AgentProvider::list_agents().join(", ");
            return Err(
                format!("Unknown agent '{agent}'. Available agents: {available_agents}").into(),
            );
        }

        // Validate task type
        if task_type != "generic" {
            // Create asset manager for template validation
            let asset_manager = LayeredAssetManager::new_with_standard_layers(
                Some(&repo_root),
                &ctx.xdg_directories(),
            );
            let available_templates = asset_manager.list_templates();
            if !available_templates.contains(&task_type.to_string()) {
                return Err(format!(
                    "No template found for task type '{}'. Available templates: {}",
                    task_type,
                    available_templates.join(", ")
                )
                .into());
            }
        }

        // Create task directory in centralized location
        let now = chrono::Local::now();
        let timestamp = now.format("%Y-%m-%d-%H%M");
        let created_at = now;
        let id = format!("{timestamp}-{task_type}-{name}");
        let task_dir_name = id.clone();
        let repo_hash = crate::storage::get_repo_hash(&repo_root);
        let task_dir = ctx.xdg_directories().task_dir(&task_dir_name, &repo_hash);
        ctx.file_system().create_dir(&task_dir).await?;

        // Create instructions file
        let instructions_path = if self.edit {
            // Create temporary file in repository root for editing
            let temp_filename = format!(".tsk-edit-{task_dir_name}-instructions.md");
            let temp_path = repo_root.join(&temp_filename);
            self.write_instructions_content(&temp_path, &task_type, ctx)
                .await?;

            // Open editor with the temporary file
            self.open_editor(temp_path.to_str().ok_or("Invalid path")?)?;
            self.check_instructions_not_empty(&temp_path, ctx).await?;

            // Move the file to the task directory
            let final_path = task_dir.join("instructions.md");
            let content = ctx.file_system().read_file(&temp_path).await?;
            ctx.file_system().write_file(&final_path, &content).await?;
            ctx.file_system().remove_file(&temp_path).await?;

            final_path.to_string_lossy().to_string()
        } else {
            // Create instructions file directly in task directory
            let dest_path = task_dir.join("instructions.md");
            self.write_instructions_content(&dest_path, &task_type, ctx)
                .await?
        };

        // Capture the current commit SHA
        let source_commit = match ctx.git_operations().get_current_commit(&repo_root).await {
            Ok(commit) => commit,
            Err(e) => {
                return Err(format!("Failed to get current commit for task '{name}': {e}").into());
            }
        };

        // Auto-detect tech_stack and project if not provided
        let tech_stack = match self.tech_stack {
            Some(ts) => {
                println!("Using tech stack: {ts}");
                ts
            }
            None => match ctx.repository_context().detect_tech_stack(&repo_root).await {
                Ok(detected) => {
                    println!("Auto-detected tech stack: {detected}");
                    detected
                }
                Err(e) => {
                    eprintln!("Warning: Failed to detect tech stack: {e}. Using default.");
                    "default".to_string()
                }
            },
        };

        let project = match self.project {
            Some(p) => {
                println!("Using project: {p}");
                p
            }
            None => {
                match ctx
                    .repository_context()
                    .detect_project_name(&repo_root)
                    .await
                {
                    Ok(detected) => {
                        println!("Auto-detected project name: {detected}");
                        detected
                    }
                    Err(e) => {
                        eprintln!("Warning: Failed to detect project name: {e}. Using default.");
                        "default".to_string()
                    }
                }
            }
        };

        // Generate branch name from task ID
        let branch_name = format!("tsk/{task_dir_name}");

        // Copy the repository for the task
        let repo_manager = RepoManager::new(
            ctx.xdg_directories(),
            ctx.file_system(),
            ctx.git_operations(),
        );

        let (copied_repo_path, _) = repo_manager
            .copy_repo(&task_dir_name, &repo_root, Some(&source_commit))
            .await
            .map_err(|e| format!("Failed to copy repository: {e}"))?;

        // Create and return the task
        let task = Task::new(
            id,
            repo_root,
            name,
            task_type,
            instructions_path,
            agent,
            timeout,
            branch_name,
            source_commit,
            tech_stack,
            project,
            created_at,
            copied_repo_path,
        );

        Ok(task)
    }

    async fn write_instructions_content(
        &self,
        dest_path: &Path,
        task_type: &str,
        ctx: &AppContext,
    ) -> Result<String, Box<dyn Error>> {
        let fs = ctx.file_system();

        if let Some(ref file_path) = self.instructions_file_path {
            // File path provided - read and copy content
            let content = fs.read_file(file_path).await?;
            fs.write_file(dest_path, &content).await?;
        } else if let Some(ref desc) = self.description {
            // Check if a template exists for this task type
            let content = if task_type != "generic" {
                // Create asset manager for template retrieval
                let asset_manager = LayeredAssetManager::new_with_standard_layers(
                    self.repo_root.as_deref(),
                    &ctx.xdg_directories(),
                );
                match asset_manager.get_template(task_type) {
                    Ok(template_content) => template_content.replace("{{DESCRIPTION}}", desc),
                    Err(e) => {
                        eprintln!("Warning: Failed to read template: {e}");
                        desc.clone()
                    }
                }
            } else {
                desc.clone()
            };

            fs.write_file(dest_path, &content).await?;
        } else {
            // Create empty instructions file for editing
            let initial_content = if task_type != "generic" {
                // Create asset manager for template retrieval
                let asset_manager = LayeredAssetManager::new_with_standard_layers(
                    self.repo_root.as_deref(),
                    &ctx.xdg_directories(),
                );
                match asset_manager.get_template(task_type) {
                    Ok(template_content) => template_content.replace(
                        "{{DESCRIPTION}}",
                        "<!-- TODO: Add your task description here -->",
                    ),
                    Err(_) => String::new(),
                }
            } else {
                String::new()
            };

            fs.write_file(dest_path, &initial_content).await?;
        }

        println!("Created instructions file: {}", dest_path.display());
        Ok(dest_path.to_string_lossy().to_string())
    }

    fn open_editor(&self, instructions_path: &str) -> Result<(), Box<dyn Error>> {
        let editor = std::env::var("EDITOR").unwrap_or_else(|_| {
            if std::env::var("VISUAL").is_ok() {
                std::env::var("VISUAL").unwrap()
            } else {
                "vi".to_string()
            }
        });

        println!("Opening instructions file in editor: {editor}");

        let status = std::process::Command::new(&editor)
            .arg(instructions_path)
            .status()?;

        if !status.success() {
            return Err("Editor exited with non-zero status".into());
        }

        Ok(())
    }

    async fn check_instructions_not_empty(
        &self,
        instructions_path: &Path,
        ctx: &AppContext,
    ) -> Result<(), Box<dyn Error>> {
        // Check if file is empty after editing
        let content = ctx.file_system().read_file(instructions_path).await?;
        if content.trim().is_empty() {
            return Err("Instructions file is empty. Task creation cancelled.".into());
        }
        Ok(())
    }
}

impl Default for TaskBuilder {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::context::AppContext;
    use crate::context::file_system::{FileSystemOperations, tests::MockFileSystem};
    use crate::context::git_operations::tests::MockGitOperations;
    use std::sync::Arc;
    use tempfile::TempDir;

    /// Helper to create a standard test context with mocked file system and git operations
    fn create_test_context() -> (TempDir, PathBuf, AppContext) {
        let temp_dir = TempDir::new().unwrap();
        let current_dir = temp_dir.path().to_path_buf();
        let xdg = crate::storage::XdgDirectories::new_with_paths(
            temp_dir.path().join("data"),
            temp_dir.path().join("runtime"),
            temp_dir.path().join("config"),
            temp_dir.path().join("cache"),
        );

        let fs = Arc::new(
            MockFileSystem::new()
                .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string())
                .with_dir(&current_dir.join(".git").to_string_lossy().to_string()),
        );

        let git_ops = Arc::new(MockGitOperations::new());
        git_ops.set_get_current_commit_result(Ok("abc123".to_string()));
        git_ops.set_is_repo_result(Ok(true));
        git_ops.set_get_tracked_files_result(Ok(vec![]));

        let ctx = AppContext::builder()
            .with_file_system(fs)
            .with_git_operations(git_ops)
            .with_xdg_directories(Arc::new(xdg))
            .build();

        (temp_dir, current_dir, ctx)
    }

    /// Helper to create a test task with default values
    fn create_test_task(id: &str, name: &str, task_type: &str) -> Task {
        Task::new(
            id.to_string(),
            PathBuf::from("/test"),
            name.to_string(),
            task_type.to_string(),
            "instructions.md".to_string(),
            "claude-code".to_string(),
            30,
            format!("tsk/{id}"),
            "abc123".to_string(),
            "default".to_string(),
            "default".to_string(),
            chrono::Local::now(),
            PathBuf::from("/test/copied"),
        )
    }

    #[tokio::test]
    async fn test_task_builder_basic() {
        let (_temp_dir, current_dir, ctx) = create_test_context();

        let task = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("test-task".to_string())
            .task_type("generic".to_string())
            .description(Some("Test description".to_string()))
            .timeout(60)
            .build(&ctx)
            .await
            .unwrap();

        assert_eq!(task.name, "test-task");
        assert_eq!(task.task_type, "generic");
        assert_eq!(task.timeout, 60);
        assert!(!task.instructions_file.is_empty());
        assert!(task.id.contains("test-task"));
    }

    #[tokio::test]
    async fn test_task_builder_with_template() {
        let (temp_dir, current_dir, _) = create_test_context();
        let template_content = "# Feature Template\n\n{{DESCRIPTION}}";
        let template_dir = current_dir.join(".tsk/templates");

        // Create a new context with template files
        let xdg = crate::storage::XdgDirectories::new_with_paths(
            temp_dir.path().join("data"),
            temp_dir.path().join("runtime"),
            temp_dir.path().join("config"),
            temp_dir.path().join("cache"),
        );

        let fs = Arc::new(
            MockFileSystem::new()
                .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string())
                .with_dir(&template_dir.to_string_lossy().to_string())
                .with_file(
                    &template_dir.join("feat.md").to_string_lossy().to_string(),
                    template_content,
                )
                .with_dir(&current_dir.join(".git").to_string_lossy().to_string()),
        );

        let git_ops = Arc::new(MockGitOperations::new());
        git_ops.set_get_current_commit_result(Ok("abc123".to_string()));
        git_ops.set_is_repo_result(Ok(true));
        git_ops.set_get_tracked_files_result(Ok(vec![]));

        let ctx = AppContext::builder()
            .with_file_system(fs.clone())
            .with_git_operations(git_ops)
            .with_xdg_directories(Arc::new(xdg))
            .build();

        let task = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("test-feature".to_string())
            .task_type("feat".to_string())
            .description(Some("My feature description".to_string()))
            .build(&ctx)
            .await
            .unwrap();

        assert_eq!(task.task_type, "feat");

        // Verify instructions file was created with template
        let instructions_path = &task.instructions_file;
        let content = fs.read_file(Path::new(instructions_path)).await.unwrap();
        // Check that the template was applied and description was injected
        assert!(content.contains("My feature description"));
        assert!(content.contains("Feature"));
    }

    #[tokio::test]
    async fn test_task_builder_validation_no_input() {
        let temp_dir = TempDir::new().unwrap();
        let current_dir = temp_dir.path().to_path_buf();
        let fs = Arc::new(
            MockFileSystem::new()
                .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string()),
        );

        let ctx = AppContext::builder().with_file_system(fs).build();

        let result = TaskBuilder::new()
            .repo_root(current_dir)
            .name("test-task".to_string())
            .build(&ctx)
            .await;

        assert!(result.is_err());
        let err = result.unwrap_err().to_string();
        assert!(
            err.contains("Either description or instructions file")
                || err.contains("Repository root is required")
        );
    }

    #[tokio::test]
    async fn test_task_builder_with_instructions_file() {
        let (temp_dir, current_dir, _) = create_test_context();
        let instructions_content = "# Instructions for task";
        let instructions_path = current_dir.join("test-instructions.md");

        // Create a new context with instructions file
        let xdg = crate::storage::XdgDirectories::new_with_paths(
            temp_dir.path().join("data"),
            temp_dir.path().join("runtime"),
            temp_dir.path().join("config"),
            temp_dir.path().join("cache"),
        );

        let fs = Arc::new(
            MockFileSystem::new()
                .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string())
                .with_file(
                    &instructions_path.to_string_lossy().to_string(),
                    instructions_content,
                )
                .with_dir(&current_dir.join(".git").to_string_lossy().to_string()),
        );

        let git_ops = Arc::new(MockGitOperations::new());
        git_ops.set_get_current_commit_result(Ok("abc123".to_string()));
        git_ops.set_is_repo_result(Ok(true));
        git_ops.set_get_tracked_files_result(Ok(vec![]));

        let ctx = AppContext::builder()
            .with_file_system(fs.clone())
            .with_git_operations(git_ops)
            .with_xdg_directories(Arc::new(xdg))
            .build();

        let task = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("test-task".to_string())
            .instructions_file(Some(instructions_path.clone()))
            .build(&ctx)
            .await
            .unwrap();

        // Verify instructions file was copied
        let task_instructions_path = &task.instructions_file;
        let content = fs
            .read_file(Path::new(task_instructions_path))
            .await
            .unwrap();
        assert_eq!(content, instructions_content);
    }

    #[tokio::test]
    async fn test_task_builder_write_instructions_content() {
        let temp_dir = TempDir::new().unwrap();
        let current_dir = temp_dir.path().to_path_buf();

        // Test 1: Basic write without template
        {
            let fs = Arc::new(
                MockFileSystem::new()
                    .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string()),
            );

            let ctx = AppContext::builder().with_file_system(fs.clone()).build();

            let task_builder = TaskBuilder::new()
                .name("test-task".to_string())
                .task_type("generic".to_string())
                .description(Some("Test description".to_string()));

            let temp_path = Path::new(".tsk-edit-2024-01-01-1200-test-task-instructions.md");
            let result_path = task_builder
                .write_instructions_content(temp_path, "generic", &ctx)
                .await
                .unwrap();

            assert_eq!(result_path, temp_path.to_string_lossy().to_string());
            let content = fs.read_file(temp_path).await.unwrap();
            assert!(content.contains("Test description"));
        }

        // Test 2: Write with template
        {
            let template_content = "# Feature Template\n\n{{DESCRIPTION}}";
            let template_dir = current_dir.join(".tsk/templates");

            let fs = Arc::new(
                MockFileSystem::new()
                    .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string())
                    .with_dir(&template_dir.to_string_lossy().to_string())
                    .with_file(
                        &template_dir.join("feat.md").to_string_lossy().to_string(),
                        template_content,
                    ),
            );

            let ctx = AppContext::builder().with_file_system(fs.clone()).build();

            let task_builder = TaskBuilder::new()
                .name("test-feature".to_string())
                .task_type("feat".to_string())
                .description(Some("My new feature".to_string()));

            let temp_path = Path::new(".tsk-edit-2024-01-01-1200-test-feature-instructions.md");
            task_builder
                .write_instructions_content(temp_path, "feat", &ctx)
                .await
                .unwrap();

            let content = fs.read_file(temp_path).await.unwrap();
            assert!(content.contains("My new feature"));
            assert!(content.contains("Feature"));
            assert!(!content.contains("{{DESCRIPTION}}"));
        }
    }

    #[tokio::test]
    async fn test_task_builder_captures_source_commit() {
        let (temp_dir, current_dir, _) = create_test_context();

        // Create context with specific commit SHA
        let xdg = crate::storage::XdgDirectories::new_with_paths(
            temp_dir.path().join("data"),
            temp_dir.path().join("runtime"),
            temp_dir.path().join("config"),
            temp_dir.path().join("cache"),
        );

        let fs = Arc::new(
            MockFileSystem::new()
                .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string())
                .with_dir(&current_dir.join(".git").to_string_lossy().to_string()),
        );

        let mock_git_ops = Arc::new(MockGitOperations::new());
        mock_git_ops.set_get_current_commit_result(Ok(
            "abc123def456789012345678901234567890abcd".to_string()
        ));

        let ctx = AppContext::builder()
            .with_file_system(fs.clone())
            .with_git_operations(mock_git_ops.clone())
            .with_xdg_directories(Arc::new(xdg))
            .build();

        let task = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("test-task".to_string())
            .task_type("generic".to_string())
            .description(Some("Test description".to_string()))
            .build(&ctx)
            .await
            .unwrap();

        // Verify the source commit was captured
        assert_eq!(
            task.source_commit,
            "abc123def456789012345678901234567890abcd".to_string()
        );

        // Verify the git operation was called
        let calls = mock_git_ops.get_get_current_commit_calls();
        assert_eq!(calls.len(), 1);
        assert_eq!(calls[0], current_dir.to_string_lossy().to_string());
    }

    #[tokio::test]
    async fn test_task_builder_from_existing() {
        let temp_dir = TempDir::new().unwrap();
        let current_dir = temp_dir.path().to_path_buf();

        // Test 1: Successful build from existing task
        {
            let instructions_content = "# Task Instructions\n\nOriginal instructions content";
            let instructions_path = current_dir.join("test-instructions.md");

            let fs = Arc::new(
                MockFileSystem::new()
                    .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string())
                    .with_file(
                        &instructions_path.to_string_lossy().to_string(),
                        instructions_content,
                    ),
            );

            let git_ops = Arc::new(MockGitOperations::new());
            git_ops.set_get_current_commit_result(Ok("abc123".to_string()));

            let ctx = AppContext::builder()
                .with_file_system(fs.clone())
                .with_git_operations(git_ops.clone())
                .build();

            // Create an existing task
            let existing_task = Task::new(
                "2024-01-01-1200-generic-existing-task".to_string(),
                current_dir.clone(),
                "existing-task".to_string(),
                "generic".to_string(),
                instructions_path.to_string_lossy().to_string(),
                "claude-code".to_string(),
                45,
                "tsk/2024-01-01-1200-generic-existing-task".to_string(),
                "abc123".to_string(),
                "default".to_string(),
                "default".to_string(),
                chrono::Local::now(),
                current_dir.clone(),
            );

            // Create a builder from the existing task
            let builder = TaskBuilder::from_existing(&existing_task);

            // Build a new task from it
            let new_task = builder
                .name("retry-task".to_string())
                .build(&ctx)
                .await
                .unwrap();

            // Verify the new task has the same properties
            assert_eq!(new_task.name, "retry-task");
            assert_eq!(new_task.task_type, "generic");
            assert_eq!(new_task.agent, "claude-code".to_string());
            assert_eq!(new_task.timeout, 45);
            assert!(!new_task.instructions_file.is_empty());

            // Verify the instructions file path was preserved and content was copied
            let copied_content = fs
                .read_file(Path::new(&new_task.instructions_file))
                .await
                .unwrap();
            assert_eq!(copied_content, instructions_content);
        }

        // Test 2: Fail when instructions file is missing
        {
            let instructions_path = current_dir.join("missing-instructions.md");

            let fs = Arc::new(
                MockFileSystem::new()
                    .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string()),
            );

            let git_ops = Arc::new(MockGitOperations::new());
            git_ops.set_get_current_commit_result(Ok("abc123".to_string()));

            let ctx = AppContext::builder()
                .with_file_system(fs.clone())
                .with_git_operations(git_ops.clone())
                .build();

            // Create an existing task with missing instructions file
            let mut existing_task = create_test_task(
                "2024-01-01-1200-generic-existing-task",
                "existing-task",
                "generic",
            );
            existing_task.instructions_file = instructions_path.to_string_lossy().to_string();
            existing_task.repo_root = current_dir.clone();
            existing_task.copied_repo_path = current_dir.clone();

            // Create a builder from the existing task
            let builder = TaskBuilder::from_existing(&existing_task);

            // Build a new task from it - should fail because instructions file doesn't exist
            let result = builder.name("retry-task".to_string()).build(&ctx).await;

            // Verify it fails with appropriate error
            assert!(result.is_err());
            let err = result.unwrap_err().to_string();
            assert!(err.contains("missing-instructions.md"));
        }
    }

    #[tokio::test]
    async fn test_task_builder_handles_source_commit_error() {
        let temp_dir = TempDir::new().unwrap();
        let current_dir = temp_dir.path().to_path_buf();
        let fs = Arc::new(
            MockFileSystem::new()
                .with_dir(&current_dir.join(".tsk/tasks").to_string_lossy().to_string()),
        );

        let mock_git_ops = Arc::new(MockGitOperations::new());
        mock_git_ops.set_get_current_commit_result(Err("Not a git repository".to_string()));

        let ctx = AppContext::builder()
            .with_file_system(fs.clone())
            .with_git_operations(mock_git_ops.clone())
            .build();

        let result = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("test-task".to_string())
            .task_type("generic".to_string())
            .description(Some("Test description".to_string()))
            .build(&ctx)
            .await;

        // Task creation should fail because getting commit failed
        assert!(result.is_err());
        let err = result.unwrap_err().to_string();
        assert!(err.contains("Failed to get current commit"));

        // Verify the git operation was called
        let calls = mock_git_ops.get_get_current_commit_calls();
        assert_eq!(calls.len(), 1);
    }

    #[tokio::test]
    async fn test_task_builder_with_docker_config() {
        let (_temp_dir, current_dir, ctx) = create_test_context();

        let task = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("test-task".to_string())
            .task_type("generic".to_string())
            .description(Some("Test description".to_string()))
            .tech_stack(Some("rust".to_string()))
            .project(Some("web-api".to_string()))
            .timeout(60)
            .build(&ctx)
            .await
            .unwrap();

        assert_eq!(task.name, "test-task");
        assert_eq!(task.tech_stack, "rust".to_string());
        assert_eq!(task.project, "web-api".to_string());
    }

    #[tokio::test]
    async fn test_task_builder_from_existing_preserves_docker_config() {
        let temp_dir = TempDir::new().unwrap();
        let current_dir = temp_dir.path().to_path_buf();

        // Create an existing task with Docker config
        let mut existing_task = create_test_task(
            "2024-01-01-1200-generic-existing-task",
            "existing-task",
            "generic",
        );
        existing_task.repo_root = current_dir.clone();
        existing_task.tech_stack = "python".to_string();
        existing_task.project = "ml-service".to_string();

        // Create a builder from the existing task
        let builder = TaskBuilder::from_existing(&existing_task);

        // Verify Docker config is preserved
        assert_eq!(builder.tech_stack, Some("python".to_string()));
        assert_eq!(builder.project, Some("ml-service".to_string()));
    }

    #[tokio::test]
    async fn test_task_id_generation_with_task_type() {
        let (_temp_dir, current_dir, ctx) = create_test_context();

        // Test with "feat" task type
        let task = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("new-feature".to_string())
            .task_type("feat".to_string())
            .description(Some("Test feature".to_string()))
            .build(&ctx)
            .await
            .unwrap();

        // Verify task ID format includes task type
        assert!(task.id.contains("-feat-new-feature"));
        assert_eq!(task.task_type, "feat");

        // Test with "fix" task type
        let task2 = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("bug-fix".to_string())
            .task_type("fix".to_string())
            .description(Some("Test fix".to_string()))
            .build(&ctx)
            .await
            .unwrap();

        assert!(task2.id.contains("-fix-bug-fix"));
        assert_eq!(task2.task_type, "fix");

        // Test branch name generation follows the same pattern
        let branch_name = format!("tsk/{}", task.id);
        assert!(branch_name.contains("tsk/"));
        assert!(branch_name.contains("-feat-new-feature"));
    }

    #[test]
    fn test_task_new_with_id() {
        let task = create_test_task("2024-01-01-1200-feat-test-task", "test-task", "feat");

        // Verify task ID is set correctly
        assert_eq!(task.id, "2024-01-01-1200-feat-test-task");
        assert_eq!(task.task_type, "feat");
        assert_eq!(task.name, "test-task");
    }

    #[tokio::test]
    async fn test_task_builder_copies_repository() {
        let (temp_dir, current_dir, _) = create_test_context();

        // Create context with tracked files
        let xdg = crate::storage::XdgDirectories::new_with_paths(
            temp_dir.path().join("data"),
            temp_dir.path().join("runtime"),
            temp_dir.path().join("config"),
            temp_dir.path().join("cache"),
        );

        let fs = Arc::new(
            MockFileSystem::new()
                .with_dir(&current_dir.join(".git").to_string_lossy().to_string())
                .with_file(
                    &current_dir.join("test.txt").to_string_lossy().to_string(),
                    "content",
                ),
        );

        let git_ops = Arc::new(MockGitOperations::new());
        git_ops.set_get_current_commit_result(Ok("abc123".to_string()));
        git_ops.set_is_repo_result(Ok(true));
        git_ops.set_get_tracked_files_result(Ok(vec![PathBuf::from("test.txt")]));

        let ctx = AppContext::builder()
            .with_file_system(fs.clone())
            .with_git_operations(git_ops)
            .with_xdg_directories(Arc::new(xdg))
            .build();

        let task = TaskBuilder::new()
            .repo_root(current_dir.clone())
            .name("test-task".to_string())
            .task_type("generic".to_string())
            .description(Some("Test description".to_string()))
            .build(&ctx)
            .await
            .unwrap();

        // Verify the task has a copied_repo_path
        let copied_path = &task.copied_repo_path;

        // Verify the copied path contains the task directory structure
        assert!(copied_path.to_string_lossy().contains(&task.id));
        assert!(copied_path.to_string_lossy().contains("repo"));
    }
}