refactor: use individual API for single-task hard delete in TUI (#806)

RemoveTaskUseCase and the DELETE endpoint now return
TaskOperationOutput, consistent with all other single-task operations.
This allows HardDeleteCommand to implement execute_single() so that
deleting one task uses the individual API instead of the bulk endpoint.

Changes:
- core: RemoveTaskUseCase returns TaskOperationOutput (captured before
  deletion)
- core: TaskCrudController.remove_task returns TaskOperationOutput
- server: DELETE /api/v1/tasks/{id} returns TaskOperationResponse
  (200 instead of 204), removes redundant pre-fetch of task data
- client: remove_task returns TaskOperationOutput
- TUI: HardDeleteCommand adds execute_single for individual API

Author: Kohei-Wada

packages/taskdog-client/src/taskdog_client/task_client.py

@@ -201,15 +201,17 @@ def restore_task(self, task_id: int) -> TaskOperationOutput:
         """
         return self._base.lifecycle_operation(task_id, "restore")
 
-    def remove_task(self, task_id: int) -> None:
+    def remove_task(self, task_id: int) -> TaskOperationOutput:
         """Permanently delete a task.
 
         Args:
             task_id: Task ID
 
+        Returns:
+            TaskOperationOutput with deleted task data
+
         Raises:
             TaskNotFoundException: If task not found
         """
-        response = self._base._safe_request("delete", f"/api/v1/tasks/{task_id}")
-        if not response.is_success:
-            self._base._handle_error(response)
+        data = self._base._request_json("delete", f"/api/v1/tasks/{task_id}")
+        return convert_to_task_operation_output(data)

packages/taskdog-client/src/taskdog_client/taskdog_api_client.py

@@ -189,7 +189,7 @@ def restore_task(self, task_id: int) -> TaskOperationOutput:
         """Restore an archived task."""
         return self._tasks.restore_task(task_id)
 
-    def remove_task(self, task_id: int) -> None:
+    def remove_task(self, task_id: int) -> TaskOperationOutput:
         """Permanently delete a task."""
         return self._tasks.remove_task(task_id)
 

packages/taskdog-client/tests/test_task_client.py

@@ -139,23 +139,14 @@ def test_archive_restore_operations(self, method_name, expected_operation):
         assert result == mock_output
 
     def test_remove_task(self):
-        """Test remove_task makes correct API call."""
-        mock_response = Mock()
-        mock_response.is_success = True
-        self.mock_base._safe_request.return_value = mock_response
+        """Test remove_task makes correct API call and returns TaskOperationOutput."""
+        mock_data = {"id": 1, "name": "Task 1", "status": "PENDING", "priority": 50}
+        self.mock_base._request_json.return_value = mock_data
 
-        self.client.remove_task(task_id=1)
+        result = self.client.remove_task(task_id=1)
 
-        self.mock_base._safe_request.assert_called_once_with(
+        self.mock_base._request_json.assert_called_once_with(
             "delete", "/api/v1/tasks/1"
         )
-
-    def test_remove_task_not_found(self):
-        """Test remove_task handles not found error."""
-        mock_response = Mock()
-        mock_response.is_success = False
-        self.mock_base._safe_request.return_value = mock_response
-
-        self.client.remove_task(task_id=999)
-
-        self.mock_base._handle_error.assert_called_once_with(mock_response)
+        assert result.id == 1
+        assert result.name == "Task 1"

packages/taskdog-core/src/taskdog_core/application/services/optimization/earliest_deadline_optimization_strategy.py

@@ -24,7 +24,9 @@ def _sort_tasks(self, tasks: list[Task], start_date: datetime) -> list[Task]:
         """Sort tasks by deadline (earliest first)."""
         return sorted(
             tasks,
-            key=lambda t: t.deadline
-            if t.deadline is not None
-            else datetime(9999, 12, 31, 23, 59, 59),
+            key=lambda t: (
+                t.deadline
+                if t.deadline is not None
+                else datetime(9999, 12, 31, 23, 59, 59)
+            ),
         )

packages/taskdog-core/src/taskdog_core/application/use_cases/remove_task.py

@@ -1,12 +1,13 @@
 """Use case for removing a task."""
 
 from taskdog_core.application.dto.base import SingleTaskInput
+from taskdog_core.application.dto.task_operation_output import TaskOperationOutput
 from taskdog_core.application.use_cases.base import UseCase
 from taskdog_core.domain.repositories.notes_repository import NotesRepository
 from taskdog_core.domain.repositories.task_repository import TaskRepository
 
 
-class RemoveTaskUseCase(UseCase[SingleTaskInput, None]):
+class RemoveTaskUseCase(UseCase[SingleTaskInput, TaskOperationOutput]):
     """Use case for removing tasks."""
 
     def __init__(self, repository: TaskRepository, notes_repository: NotesRepository):
@@ -19,21 +20,30 @@ def __init__(self, repository: TaskRepository, notes_repository: NotesRepository
         self.repository = repository
         self.notes_repository = notes_repository
 
-    def execute(self, input_dto: SingleTaskInput) -> None:
+    def execute(self, input_dto: SingleTaskInput) -> TaskOperationOutput:
         """Execute task removal.
 
         Deletes both the task and its associated notes file (if any).
+        Returns task information captured before deletion.
 
         Args:
             input_dto: Task removal input data
 
+        Returns:
+            TaskOperationOutput containing the deleted task's information
+
         Raises:
             TaskNotFoundException: If task doesn't exist
         """
-        self._get_task_or_raise(self.repository, input_dto.task_id)
+        task = self._get_task_or_raise(self.repository, input_dto.task_id)
+
+        # Capture task info before deletion
+        result = TaskOperationOutput.from_task(task)
 
         # Delete notes first (idempotent - won't fail if notes don't exist)
         self.notes_repository.delete_notes(input_dto.task_id)
 
         # Then delete the task
         self.repository.delete(input_dto.task_id)
+
+        return result

packages/taskdog-core/src/taskdog_core/controllers/task_crud_controller.py

@@ -231,14 +231,17 @@ def restore_task(self, task_id: int) -> TaskOperationOutput:
 
         return result
 
-    def remove_task(self, task_id: int) -> None:
+    def remove_task(self, task_id: int) -> TaskOperationOutput:
         """Remove a task (hard delete).
 
         Permanently deletes the task and its associated notes from storage.
 
         Args:
             task_id: ID of the task to remove
 
+        Returns:
+            TaskOperationOutput containing the deleted task's information
+
         Raises:
             TaskNotFoundException: If task not found
         """
@@ -248,8 +251,10 @@ def remove_task(self, task_id: int) -> None:
 
         use_case = RemoveTaskUseCase(self.repository, self.notes_repository)
         request = SingleTaskInput(task_id=task_id)
-        use_case.execute(request)
+        result = use_case.execute(request)
 
         self.logger.info(
             f"Task removed successfully: task_id={task_id}", task_id=task_id
         )
+
+        return result

packages/taskdog-core/tests/application/queries/filters/test_task_filter.py

@@ -123,13 +123,15 @@ def test_rshift_operator_with_none_returns_self(self):
         "composed_factory,expected_filter_count",
         [
             (
-                lambda: (PendingOnlyFilter() >> HighPriorityFilter())
-                >> ConcreteFilter(),
+                lambda: (
+                    (PendingOnlyFilter() >> HighPriorityFilter()) >> ConcreteFilter()
+                ),
                 3,
             ),
             (
-                lambda: PendingOnlyFilter()
-                >> (HighPriorityFilter() >> ConcreteFilter()),
+                lambda: (
+                    PendingOnlyFilter() >> (HighPriorityFilter() >> ConcreteFilter())
+                ),
                 3,
             ),
         ],

packages/taskdog-server/src/taskdog_server/api/routers/tasks.py

@@ -6,7 +6,6 @@
 from fastapi import APIRouter, Query, status
 
 from taskdog_core.application.dto.query_inputs import ListTasksInput
-from taskdog_core.domain.exceptions.task_exceptions import TaskNotFoundException
 from taskdog_server.api.converters import (
     convert_to_task_detail_response,
     convert_to_task_list_response,
@@ -371,47 +370,43 @@ async def restore_task(
     return TaskOperationResponse.from_dto(result)
 
 
-@router.delete("/{task_id}", status_code=status.HTTP_204_NO_CONTENT)
+@router.delete("/{task_id}")
 @handle_task_errors
 async def delete_task(
     task_id: int,
     controller: CrudControllerDep,
-    query_controller: QueryControllerDep,
     broadcaster: EventBroadcasterDep,
     audit_controller: AuditLogControllerDep,
     client_name: AuthenticatedClientDep,
-) -> None:
+) -> TaskOperationResponse:
     """Permanently delete a task.
 
     Args:
         task_id: Task ID
         controller: CRUD controller dependency
-        query_controller: Query controller dependency (for fetching task name before deletion)
         broadcaster: Event broadcaster dependency
         audit_controller: Audit log controller dependency
         client_name: Authenticated client name (for broadcast payload)
 
+    Returns:
+        Deleted task data
+
     Raises:
         HTTPException: 404 if task not found
     """
-    # Get task name before deletion for notification
-    task_output = query_controller.get_task_by_id(task_id)
-    if task_output is None or task_output.task is None:
-        raise TaskNotFoundException(f"Task {task_id} not found")
-    task_name = task_output.task.name
-
-    # Delete task
-    controller.remove_task(task_id)
+    result = controller.remove_task(task_id)
 
     # Broadcast WebSocket event in background
-    broadcaster.task_deleted(task_id, task_name, client_name)
+    broadcaster.task_deleted(task_id, result.name, client_name)
 
     # Audit log
     audit_controller.log_operation(
         operation="delete_task",
         resource_type="task",
         resource_id=task_id,
-        resource_name=task_name,
+        resource_name=result.name,
         client_name=client_name,
         success=True,
     )
+
+    return TaskOperationResponse.from_dto(result)

packages/taskdog-server/tests/api/routers/test_tasks.py

@@ -311,7 +311,10 @@ def test_delete_task_success(self, client, repository, task_factory):
         response = client.delete(f"/api/v1/tasks/{task.id}")
 
         # Assert
-        assert response.status_code == 204
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == task.id
+        assert data["name"] == "Test Task"
 
         # Verify task is deleted
         deleted_task = repository.get_by_id(task.id)

packages/taskdog-ui/src/taskdog/tui/commands/hard_delete.py

@@ -2,6 +2,7 @@
 
 from taskdog.tui.commands.batch_command_base import BatchCommandBase
 from taskdog_core.application.dto.bulk_operation_output import BulkOperationOutput
+from taskdog_core.application.dto.task_operation_output import TaskOperationOutput
 
 
 class HardDeleteCommand(BatchCommandBase):
@@ -19,6 +20,9 @@ def get_confirmation_config(self) -> tuple[str, str, str]:
             "[!] All tasks will be completely removed from the database.",
         )
 
+    def execute_single(self, task_id: int) -> TaskOperationOutput:
+        return self.context.api_client.remove_task(task_id)
+
     def execute_bulk(self, task_ids: list[int]) -> BulkOperationOutput:
         """Permanently delete tasks (hard delete) via Bulk API."""
         return self.context.api_client.bulk_delete(task_ids)