automagik-forge 0.1.13 → 0.1.14

package/backend/src/models/project.rs

@@ -1,356 +0,0 @@
-use chrono::{DateTime, Utc};
-use git2::{BranchType, Repository};
-use serde::{Deserialize, Serialize};
-use sqlx::{FromRow, SqlitePool};
-use ts_rs::TS;
-use utoipa::ToSchema;
-use uuid::Uuid;
-
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct Project {
-    pub id: Uuid,
-    pub name: String,
-    pub git_repo_path: String,
-    pub setup_script: Option<String>,
-    pub dev_script: Option<String>,
-    pub cleanup_script: Option<String>,
-
-    #[ts(type = "Date")]
-    #[schema(value_type = String, format = DateTime)]
-    pub created_at: DateTime<Utc>,
-    #[ts(type = "Date")]
-    #[schema(value_type = String, format = DateTime)]
-    pub updated_at: DateTime<Utc>,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct CreateProject {
-    pub name: String,
-    pub git_repo_path: String,
-    pub use_existing_repo: bool,
-    pub setup_script: Option<String>,
-    pub dev_script: Option<String>,
-    pub cleanup_script: Option<String>,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct UpdateProject {
-    pub name: Option<String>,
-    pub git_repo_path: Option<String>,
-    pub setup_script: Option<String>,
-    pub dev_script: Option<String>,
-    pub cleanup_script: Option<String>,
-}
-
-#[derive(Debug, Serialize, TS, ToSchema)]
-#[ts(export)]
-pub struct ProjectWithBranch {
-    pub id: Uuid,
-    pub name: String,
-    pub git_repo_path: String,
-    pub setup_script: Option<String>,
-    pub dev_script: Option<String>,
-    pub cleanup_script: Option<String>,
-    pub current_branch: Option<String>,
-
-    #[ts(type = "Date")]
-    #[schema(value_type = String, format = DateTime)]
-    pub created_at: DateTime<Utc>,
-    #[ts(type = "Date")]
-    #[schema(value_type = String, format = DateTime)]
-    pub updated_at: DateTime<Utc>,
-}
-
-#[derive(Debug, Serialize, TS, ToSchema)]
-#[ts(export)]
-pub struct SearchResult {
-    pub path: String,
-    pub is_file: bool,
-    pub match_type: SearchMatchType,
-}
-
-#[derive(Debug, Serialize, TS, ToSchema)]
-#[ts(export)]
-pub enum SearchMatchType {
-    FileName,
-    DirectoryName,
-    FullPath,
-}
-
-#[derive(Debug, Serialize, TS, ToSchema)]
-#[ts(export)]
-pub struct GitBranch {
-    pub name: String,
-    pub is_current: bool,
-    pub is_remote: bool,
-    #[ts(type = "Date")]
-    pub last_commit_date: DateTime<Utc>,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct CreateBranch {
-    pub name: String,
-    pub base_branch: Option<String>,
-}
-
-impl Project {
-    pub async fn find_all(pool: &SqlitePool) -> Result<Vec<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            Project,
-            r#"SELECT id as "id!: Uuid", name, git_repo_path, setup_script, dev_script, cleanup_script, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>" FROM projects ORDER BY created_at DESC"#
-        )
-        .fetch_all(pool)
-        .await
-    }
-
-    pub async fn find_by_id(pool: &SqlitePool, id: Uuid) -> Result<Option<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            Project,
-            r#"SELECT id as "id!: Uuid", name, git_repo_path, setup_script, dev_script, cleanup_script, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>" FROM projects WHERE id = $1"#,
-            id
-        )
-        .fetch_optional(pool)
-        .await
-    }
-
-    pub async fn find_by_git_repo_path(
-        pool: &SqlitePool,
-        git_repo_path: &str,
-    ) -> Result<Option<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            Project,
-            r#"SELECT id as "id!: Uuid", name, git_repo_path, setup_script, dev_script, cleanup_script, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>" FROM projects WHERE git_repo_path = $1"#,
-            git_repo_path
-        )
-        .fetch_optional(pool)
-        .await
-    }
-
-    pub async fn find_by_git_repo_path_excluding_id(
-        pool: &SqlitePool,
-        git_repo_path: &str,
-        exclude_id: Uuid,
-    ) -> Result<Option<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            Project,
-            r#"SELECT id as "id!: Uuid", name, git_repo_path, setup_script, dev_script, cleanup_script, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>" FROM projects WHERE git_repo_path = $1 AND id != $2"#,
-            git_repo_path,
-            exclude_id
-        )
-        .fetch_optional(pool)
-        .await
-    }
-
-    pub async fn create(
-        pool: &SqlitePool,
-        data: &CreateProject,
-        project_id: Uuid,
-    ) -> Result<Self, sqlx::Error> {
-        sqlx::query_as!(
-            Project,
-            r#"INSERT INTO projects (id, name, git_repo_path, setup_script, dev_script, cleanup_script) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id as "id!: Uuid", name, git_repo_path, setup_script, dev_script, cleanup_script, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>""#,
-            project_id,
-            data.name,
-            data.git_repo_path,
-            data.setup_script,
-            data.dev_script,
-            data.cleanup_script
-        )
-        .fetch_one(pool)
-        .await
-    }
-
-    pub async fn update(
-        pool: &SqlitePool,
-        id: Uuid,
-        name: String,
-        git_repo_path: String,
-        setup_script: Option<String>,
-        dev_script: Option<String>,
-        cleanup_script: Option<String>,
-    ) -> Result<Self, sqlx::Error> {
-        sqlx::query_as!(
-            Project,
-            r#"UPDATE projects SET name = $2, git_repo_path = $3, setup_script = $4, dev_script = $5, cleanup_script = $6 WHERE id = $1 RETURNING id as "id!: Uuid", name, git_repo_path, setup_script, dev_script, cleanup_script, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>""#,
-            id,
-            name,
-            git_repo_path,
-            setup_script,
-            dev_script,
-            cleanup_script
-        )
-        .fetch_one(pool)
-        .await
-    }
-
-    pub async fn delete(pool: &SqlitePool, id: Uuid) -> Result<u64, sqlx::Error> {
-        let result = sqlx::query!("DELETE FROM projects WHERE id = $1", id)
-            .execute(pool)
-            .await?;
-        Ok(result.rows_affected())
-    }
-
-    pub async fn exists(pool: &SqlitePool, id: Uuid) -> Result<bool, sqlx::Error> {
-        let result = sqlx::query!(
-            r#"
-                SELECT COUNT(*) as "count!: i64"
-                FROM projects
-                WHERE id = $1
-            "#,
-            id
-        )
-        .fetch_one(pool)
-        .await?;
-
-        Ok(result.count > 0)
-    }
-
-    pub fn get_current_branch(&self) -> Result<String, git2::Error> {
-        let repo = Repository::open(&self.git_repo_path)?;
-        let head = repo.head()?;
-
-        if let Some(branch_name) = head.shorthand() {
-            Ok(branch_name.to_string())
-        } else {
-            Ok("HEAD".to_string())
-        }
-    }
-
-    pub fn with_branch_info(self) -> ProjectWithBranch {
-        let current_branch = self.get_current_branch().ok();
-
-        ProjectWithBranch {
-            id: self.id,
-            name: self.name,
-            git_repo_path: self.git_repo_path,
-            setup_script: self.setup_script,
-            dev_script: self.dev_script,
-            cleanup_script: self.cleanup_script,
-            current_branch,
-            created_at: self.created_at,
-            updated_at: self.updated_at,
-        }
-    }
-
-    pub fn get_all_branches(&self) -> Result<Vec<GitBranch>, git2::Error> {
-        let repo = Repository::open(&self.git_repo_path)?;
-        let current_branch = self.get_current_branch().unwrap_or_default();
-        let mut branches = Vec::new();
-
-        // Helper function to get last commit date for a branch
-        let get_last_commit_date = |branch: &git2::Branch| -> Result<DateTime<Utc>, git2::Error> {
-            if let Some(target) = branch.get().target() {
-                if let Ok(commit) = repo.find_commit(target) {
-                    let timestamp = commit.time().seconds();
-                    return Ok(DateTime::from_timestamp(timestamp, 0).unwrap_or_else(Utc::now));
-                }
-            }
-            Ok(Utc::now()) // Default to now if we can't get the commit date
-        };
-
-        // Get local branches
-        let local_branches = repo.branches(Some(BranchType::Local))?;
-        for branch_result in local_branches {
-            let (branch, _) = branch_result?;
-            if let Some(name) = branch.name()? {
-                let last_commit_date = get_last_commit_date(&branch)?;
-                branches.push(GitBranch {
-                    name: name.to_string(),
-                    is_current: name == current_branch,
-                    is_remote: false,
-                    last_commit_date,
-                });
-            }
-        }
-
-        // Get remote branches
-        let remote_branches = repo.branches(Some(BranchType::Remote))?;
-        for branch_result in remote_branches {
-            let (branch, _) = branch_result?;
-            if let Some(name) = branch.name()? {
-                // Skip remote HEAD references
-                if !name.ends_with("/HEAD") {
-                    let last_commit_date = get_last_commit_date(&branch)?;
-                    branches.push(GitBranch {
-                        name: name.to_string(),
-                        is_current: false,
-                        is_remote: true,
-                        last_commit_date,
-                    });
-                }
-            }
-        }
-
-        // Sort branches: current first, then by most recent commit date
-        branches.sort_by(|a, b| {
-            if a.is_current && !b.is_current {
-                std::cmp::Ordering::Less
-            } else if !a.is_current && b.is_current {
-                std::cmp::Ordering::Greater
-            } else {
-                // Sort by most recent commit date (newest first)
-                b.last_commit_date.cmp(&a.last_commit_date)
-            }
-        });
-
-        Ok(branches)
-    }
-
-    pub fn create_branch(
-        &self,
-        branch_name: &str,
-        base_branch: Option<&str>,
-    ) -> Result<GitBranch, git2::Error> {
-        let repo = Repository::open(&self.git_repo_path)?;
-
-        // Get the base branch reference - default to current branch if not specified
-        let base_branch_name = match base_branch {
-            Some(name) => name.to_string(),
-            None => self
-                .get_current_branch()
-                .unwrap_or_else(|_| "HEAD".to_string()),
-        };
-
-        // Find the base commit
-        let base_commit = if base_branch_name == "HEAD" {
-            repo.head()?.peel_to_commit()?
-        } else {
-            // Try to find the branch as local first, then remote
-            let base_ref = if let Ok(local_ref) =
-                repo.find_reference(&format!("refs/heads/{}", base_branch_name))
-            {
-                local_ref
-            } else if let Ok(remote_ref) =
-                repo.find_reference(&format!("refs/remotes/{}", base_branch_name))
-            {
-                remote_ref
-            } else {
-                return Err(git2::Error::from_str(&format!(
-                    "Base branch '{}' not found",
-                    base_branch_name
-                )));
-            };
-            base_ref.peel_to_commit()?
-        };
-
-        // Create the new branch
-        let _new_branch = repo.branch(branch_name, &base_commit, false)?;
-
-        // Get the commit date for the new branch (same as base commit)
-        let last_commit_date = {
-            let timestamp = base_commit.time().seconds();
-            DateTime::from_timestamp(timestamp, 0).unwrap_or_else(Utc::now)
-        };
-
-        Ok(GitBranch {
-            name: branch_name.to_string(),
-            is_current: false,
-            is_remote: false,
-            last_commit_date,
-        })
-    }
-}

package/backend/src/models/task.rs

@@ -1,345 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use sqlx::{FromRow, SqlitePool, Type};
-use ts_rs::TS;
-use utoipa::ToSchema;
-use uuid::Uuid;
-
-#[derive(Debug, Clone, Type, Serialize, Deserialize, PartialEq, TS, ToSchema)]
-#[sqlx(type_name = "task_status", rename_all = "lowercase")]
-#[serde(rename_all = "lowercase")]
-#[ts(export)]
-pub enum TaskStatus {
-    Todo,
-    InProgress,
-    InReview,
-    Done,
-    Cancelled,
-}
-
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct Task {
-    pub id: Uuid,
-    pub project_id: Uuid, // Foreign key to Project
-    pub title: String,
-    pub description: Option<String>,
-    pub status: TaskStatus,
-    pub wish_id: String, // Required: Grouping field for task organization
-    pub parent_task_attempt: Option<Uuid>, // Foreign key to parent TaskAttempt
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct TaskWithAttemptStatus {
-    pub id: Uuid,
-    pub project_id: Uuid,
-    pub title: String,
-    pub description: Option<String>,
-    pub status: TaskStatus,
-    pub wish_id: String,
-    pub parent_task_attempt: Option<Uuid>,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
-    pub has_in_progress_attempt: bool,
-    pub has_merged_attempt: bool,
-    pub last_attempt_failed: bool,
-    pub latest_attempt_executor: Option<String>,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct CreateTask {
-    pub project_id: Uuid,
-    pub title: String,
-    pub description: Option<String>,
-    pub wish_id: String, // Required: Wish grouping identifier
-    pub parent_task_attempt: Option<Uuid>,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct CreateTaskAndStart {
-    pub project_id: Uuid,
-    pub title: String,
-    pub description: Option<String>,
-    pub wish_id: String, // Required: Wish grouping identifier
-    pub parent_task_attempt: Option<Uuid>,
-    pub executor: Option<crate::executor::ExecutorConfig>,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct UpdateTask {
-    pub title: Option<String>,
-    pub description: Option<String>,
-    pub status: Option<TaskStatus>,
-    pub wish_id: Option<String>, // Optional: Can reassign wish
-    pub parent_task_attempt: Option<Uuid>,
-}
-
-impl Task {
-    pub async fn find_by_project_id_with_attempt_status(
-        pool: &SqlitePool,
-        project_id: Uuid,
-    ) -> Result<Vec<TaskWithAttemptStatus>, sqlx::Error> {
-        let records = sqlx::query!(
-            r#"SELECT
-  t.id                            AS "id!: Uuid",
-  t.project_id                    AS "project_id!: Uuid",
-  t.title,
-  t.description,
-  t.status                        AS "status!: TaskStatus",
-  t.wish_id,
-  t.parent_task_attempt           AS "parent_task_attempt: Uuid",
-  t.created_at                    AS "created_at!: DateTime<Utc>",
-  t.updated_at                    AS "updated_at!: DateTime<Utc>",
-
-  CASE WHEN EXISTS (
-    SELECT 1
-      FROM task_attempts ta
-      JOIN execution_processes ep
-        ON ep.task_attempt_id = ta.id
-     WHERE ta.task_id       = t.id
-       AND ep.status        = 'running'
-       AND ep.process_type IN ('setupscript','cleanupscript','codingagent')
-     LIMIT 1
-  ) THEN 1 ELSE 0 END            AS "has_in_progress_attempt!: i64",
-
-  CASE WHEN EXISTS (
-    SELECT 1
-      FROM task_attempts ta
-     WHERE ta.task_id       = t.id
-       AND ta.merge_commit IS NOT NULL
-     LIMIT 1
-  ) THEN 1 ELSE 0 END            AS "has_merged_attempt!: i64",
-
-  CASE WHEN (
-    SELECT ep.status
-      FROM task_attempts ta
-      JOIN execution_processes ep
-        ON ep.task_attempt_id = ta.id
-     WHERE ta.task_id       = t.id
-     AND ep.process_type IN ('setupscript','cleanupscript','codingagent')
-     ORDER BY ep.created_at DESC
-     LIMIT 1
-  ) IN ('failed','killed') THEN 1 ELSE 0 END
-                                 AS "last_attempt_failed!: i64",
-
-  ( SELECT ta.executor
-      FROM task_attempts ta
-     WHERE ta.task_id = t.id
-     ORDER BY ta.created_at DESC
-     LIMIT 1
-  )                               AS "latest_attempt_executor"
-
-FROM tasks t
-WHERE t.project_id = $1
-ORDER BY t.created_at DESC"#,
-            project_id
-        )
-        .fetch_all(pool)
-        .await?;
-
-        let tasks = records
-            .into_iter()
-            .map(|rec| TaskWithAttemptStatus {
-                id: rec.id,
-                project_id: rec.project_id,
-                title: rec.title,
-                description: rec.description,
-                status: rec.status,
-                wish_id: rec.wish_id,
-                parent_task_attempt: rec.parent_task_attempt,
-                created_at: rec.created_at,
-                updated_at: rec.updated_at,
-                has_in_progress_attempt: rec.has_in_progress_attempt != 0,
-                has_merged_attempt: rec.has_merged_attempt != 0,
-                last_attempt_failed: rec.last_attempt_failed != 0,
-                latest_attempt_executor: rec.latest_attempt_executor,
-            })
-            .collect();
-
-        Ok(tasks)
-    }
-
-    pub async fn find_by_id(pool: &SqlitePool, id: Uuid) -> Result<Option<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            Task,
-            r#"SELECT id as "id!: Uuid", project_id as "project_id!: Uuid", title, description, status as "status!: TaskStatus", wish_id, parent_task_attempt as "parent_task_attempt: Uuid", created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>"
-               FROM tasks 
-               WHERE id = $1"#,
-            id
-        )
-        .fetch_optional(pool)
-        .await
-    }
-
-    pub async fn find_by_id_and_project_id(
-        pool: &SqlitePool,
-        id: Uuid,
-        project_id: Uuid,
-    ) -> Result<Option<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            Task,
-            r#"SELECT id as "id!: Uuid", project_id as "project_id!: Uuid", title, description, status as "status!: TaskStatus", wish_id, parent_task_attempt as "parent_task_attempt: Uuid", created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>"
-               FROM tasks 
-               WHERE id = $1 AND project_id = $2"#,
-            id,
-            project_id
-        )
-        .fetch_optional(pool)
-        .await
-    }
-
-    pub async fn create(
-        pool: &SqlitePool,
-        data: &CreateTask,
-        task_id: Uuid,
-    ) -> Result<Self, sqlx::Error> {
-        sqlx::query_as!(
-            Task,
-            r#"INSERT INTO tasks (id, project_id, title, description, status, wish_id, parent_task_attempt) 
-               VALUES ($1, $2, $3, $4, $5, $6, $7) 
-               RETURNING id as "id!: Uuid", project_id as "project_id!: Uuid", title, description, status as "status!: TaskStatus", wish_id, parent_task_attempt as "parent_task_attempt: Uuid", created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>""#,
-            task_id,
-            data.project_id,
-            data.title,
-            data.description,
-            TaskStatus::Todo as TaskStatus,
-            data.wish_id,
-            data.parent_task_attempt
-        )
-        .fetch_one(pool)
-        .await
-    }
-
-    pub async fn update(
-        pool: &SqlitePool,
-        id: Uuid,
-        project_id: Uuid,
-        title: String,
-        description: Option<String>,
-        status: TaskStatus,
-        wish_id: String,
-        parent_task_attempt: Option<Uuid>,
-    ) -> Result<Self, sqlx::Error> {
-        let status_value = status as TaskStatus;
-        sqlx::query_as!(
-            Task,
-            r#"UPDATE tasks 
-               SET title = $3, description = $4, status = $5, wish_id = $6, parent_task_attempt = $7 
-               WHERE id = $1 AND project_id = $2 
-               RETURNING id as "id!: Uuid", project_id as "project_id!: Uuid", title, description, status as "status!: TaskStatus", wish_id, parent_task_attempt as "parent_task_attempt: Uuid", created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>""#,
-            id,
-            project_id,
-            title,
-            description,
-            status_value,
-            wish_id,
-            parent_task_attempt
-        )
-        .fetch_one(pool)
-        .await
-    }
-
-    pub async fn update_status(
-        pool: &SqlitePool,
-        id: Uuid,
-        project_id: Uuid,
-        status: TaskStatus,
-    ) -> Result<(), sqlx::Error> {
-        let status_value = status as TaskStatus;
-        sqlx::query!(
-            "UPDATE tasks SET status = $3, updated_at = CURRENT_TIMESTAMP WHERE id = $1 AND project_id = $2",
-            id,
-            project_id,
-            status_value
-        )
-        .execute(pool)
-        .await?;
-        Ok(())
-    }
-
-    pub async fn delete(pool: &SqlitePool, id: Uuid, project_id: Uuid) -> Result<u64, sqlx::Error> {
-        let result = sqlx::query!(
-            "DELETE FROM tasks WHERE id = $1 AND project_id = $2",
-            id,
-            project_id
-        )
-        .execute(pool)
-        .await?;
-        Ok(result.rows_affected())
-    }
-
-    pub async fn exists(
-        pool: &SqlitePool,
-        id: Uuid,
-        project_id: Uuid,
-    ) -> Result<bool, sqlx::Error> {
-        let result = sqlx::query!(
-            "SELECT id as \"id!: Uuid\" FROM tasks WHERE id = $1 AND project_id = $2",
-            id,
-            project_id
-        )
-        .fetch_optional(pool)
-        .await?;
-        Ok(result.is_some())
-    }
-
-    pub async fn find_related_tasks_by_attempt_id(
-        pool: &SqlitePool,
-        attempt_id: Uuid,
-        project_id: Uuid,
-    ) -> Result<Vec<Self>, sqlx::Error> {
-        // Find both children and parent for this attempt
-        sqlx::query_as!(
-            Task,
-            r#"SELECT DISTINCT t.id as "id!: Uuid", t.project_id as "project_id!: Uuid", t.title, t.description, t.status as "status!: TaskStatus", t.wish_id, t.parent_task_attempt as "parent_task_attempt: Uuid", t.created_at as "created_at!: DateTime<Utc>", t.updated_at as "updated_at!: DateTime<Utc>"
-               FROM tasks t
-               WHERE (
-                   -- Find children: tasks that have this attempt as parent
-                   t.parent_task_attempt = $1 AND t.project_id = $2
-               ) OR (
-                   -- Find parent: task that owns the parent attempt of current task
-                   EXISTS (
-                       SELECT 1 FROM tasks current_task 
-                       JOIN task_attempts parent_attempt ON current_task.parent_task_attempt = parent_attempt.id
-                       WHERE parent_attempt.task_id = t.id 
-                       AND parent_attempt.id = $1 
-                       AND current_task.project_id = $2
-                   )
-               )
-               -- Exclude the current task itself to prevent circular references
-               AND t.id != (SELECT task_id FROM task_attempts WHERE id = $1)
-               ORDER BY t.created_at DESC"#,
-            attempt_id,
-            project_id
-        )
-        .fetch_all(pool)
-        .await
-    }
-
-    pub async fn link_existing_tasks(
-        pool: &SqlitePool,
-        child_task_id: Uuid,
-        parent_task_attempt: Uuid,
-        project_id: Uuid,
-    ) -> Result<Self, sqlx::Error> {
-        sqlx::query_as!(
-            Task,
-            r#"UPDATE tasks 
-               SET parent_task_attempt = $1, updated_at = CURRENT_TIMESTAMP 
-               WHERE id = $2 AND project_id = $3 
-               RETURNING id as "id!: Uuid", project_id as "project_id!: Uuid", title, description, status as "status!: TaskStatus", wish_id, parent_task_attempt as "parent_task_attempt: Uuid", created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>""#,
-            parent_task_attempt,
-            child_task_id,
-            project_id
-        )
-        .fetch_one(pool)
-        .await
-    }
-
-}