feat: add task recurrence and dependency management commands

cmd/task_commands.go

···
 		addTaskCmd, listTaskCmd, viewTaskCmd, updateTaskCmd, editTaskCmd,
 		deleteTaskCmd, taskProjectsCmd, taskTagsCmd, taskContextsCmd,
 		taskCompleteCmd, taskStartCmd, taskStopCmd, timesheetViewCmd,
+		taskRecurCmd, taskDependCmd,
 	} {
 		cmd := init(c.handler)
 		root.AddCommand(cmd)
···
 			return h.Create(c.Context(), description, priority, project, context, due, recur, until, parent, dependsOn, tags)
 		},
 	}
-	cmd.Flags().StringP("priority", "p", "", "Set task priority")
-	cmd.Flags().String("project", "", "Set task project")
-	cmd.Flags().StringP("context", "c", "", "Set task context")
-	cmd.Flags().StringP("due", "d", "", "Set due date (YYYY-MM-DD)")
-	cmd.Flags().String("recur", "", "Set recurrence rule (e.g., FREQ=DAILY)")
-	cmd.Flags().String("until", "", "Set recurrence end date (YYYY-MM-DD)")
-	cmd.Flags().String("parent", "", "Set parent task UUID")
-	cmd.Flags().String("depends-on", "", "Set task dependencies (comma-separated UUIDs)")
-	cmd.Flags().StringSliceP("tags", "t", []string{}, "Add tags to task")
+	addCommonTaskFlags(cmd)
+	addDueDateFlag(cmd)
+	addRecurrenceFlags(cmd)
+	addParentFlag(cmd)
+	addDependencyFlags(cmd)
 
 	return cmd
 }
···
 			return handler.View(cmd.Context(), args, format, jsonOutput, noMetadata)
 		},
 	}
-	viewCmd.Flags().String("format", "detailed", "Output format (detailed, brief)")
-	viewCmd.Flags().Bool("json", false, "Output as JSON")
-	viewCmd.Flags().Bool("no-metadata", false, "Hide creation/modification timestamps")
+	addOutputFlags(viewCmd)
 
 	return viewCmd
 }
···
 	}
 	updateCmd.Flags().String("description", "", "Update task description")
 	updateCmd.Flags().String("status", "", "Update task status")
-	updateCmd.Flags().StringP("priority", "p", "", "Update task priority")
-	updateCmd.Flags().String("project", "", "Update task project")
-	updateCmd.Flags().StringP("context", "c", "", "Update task context")
-	updateCmd.Flags().StringP("due", "d", "", "Update due date (YYYY-MM-DD)")
-	updateCmd.Flags().String("recur", "", "Update recurrence rule")
-	updateCmd.Flags().String("until", "", "Update recurrence end date (YYYY-MM-DD)")
-	updateCmd.Flags().String("parent", "", "Update parent task UUID")
+	addCommonTaskFlags(updateCmd)
+	addDueDateFlag(updateCmd)
+	addRecurrenceFlags(updateCmd)
+	addParentFlag(updateCmd)
 	updateCmd.Flags().StringSlice("add-tag", []string{}, "Add tags to task")
 	updateCmd.Flags().StringSlice("remove-tag", []string{}, "Remove tags from task")
 	updateCmd.Flags().String("add-depends", "", "Add task dependencies (comma-separated UUIDs)")
···
 		},
 	}
 }
+
+func taskRecurCmd(h *handlers.TaskHandler) *cobra.Command {
+	root := &cobra.Command{
+		Use:     "recur",
+		Short:   "Manage task recurrence",
+		Aliases: []string{"repeat"},
+	}
+
+	setCmd := &cobra.Command{
+		Use:   "set [task-id]",
+		Short: "Set recurrence rule for a task",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(c *cobra.Command, args []string) error {
+			rule, _ := c.Flags().GetString("rule")
+			until, _ := c.Flags().GetString("until")
+			defer h.Close()
+			return h.SetRecur(c.Context(), args[0], rule, until)
+		},
+	}
+	setCmd.Flags().String("rule", "", "Recurrence rule (e.g., FREQ=DAILY)")
+	setCmd.Flags().String("until", "", "Recurrence end date (YYYY-MM-DD)")
+
+	clearCmd := &cobra.Command{
+		Use:   "clear [task-id]",
+		Short: "Clear recurrence rule from a task",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.ClearRecur(c.Context(), args[0])
+		},
+	}
+
+	showCmd := &cobra.Command{
+		Use:   "show [task-id]",
+		Short: "Show recurrence details for a task",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.ShowRecur(c.Context(), args[0])
+		},
+	}
+
+	root.AddCommand(setCmd, clearCmd, showCmd)
+	return root
+}
+
+func taskDependCmd(h *handlers.TaskHandler) *cobra.Command {
+	root := &cobra.Command{
+		Use:     "depend",
+		Short:   "Manage task dependencies",
+		Aliases: []string{"dep", "deps"},
+	}
+
+	addCmd := &cobra.Command{
+		Use:   "add [task-id] [depends-on-uuid]",
+		Short: "Add a dependency to a task",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.AddDep(c.Context(), args[0], args[1])
+		},
+	}
+
+	removeCmd := &cobra.Command{
+		Use:     "remove [task-id] [depends-on-uuid]",
+		Short:   "Remove a dependency from a task",
+		Aliases: []string{"rm"},
+		Args:    cobra.ExactArgs(2),
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.RemoveDep(c.Context(), args[0], args[1])
+		},
+	}
+
+	listCmd := &cobra.Command{
+		Use:     "list [task-id]",
+		Short:   "List dependencies for a task",
+		Aliases: []string{"ls"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.ListDeps(c.Context(), args[0])
+		},
+	}
+
+	blockedByCmd := &cobra.Command{
+		Use:   "blocked-by [task-id]",
+		Short: "Show tasks blocked by this task",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.BlockedByDep(c.Context(), args[0])
+		},
+	}
+
+	root.AddCommand(addCmd, removeCmd, listCmd, blockedByCmd)
+	return root
+}

cmd/task_flags.go

···
+package main
+
+import "github.com/spf13/cobra"
+
+func addCommonTaskFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("priority", "p", "", "Set task priority")
+	cmd.Flags().String("project", "", "Set task project")
+	cmd.Flags().StringP("context", "c", "", "Set task context")
+	cmd.Flags().StringSliceP("tags", "t", []string{}, "Add tags to task")
+}
+
+func addRecurrenceFlags(cmd *cobra.Command) {
+	cmd.Flags().String("recur", "", "Set recurrence rule (e.g., FREQ=DAILY)")
+	cmd.Flags().String("until", "", "Set recurrence end date (YYYY-MM-DD)")
+}
+
+func addDependencyFlags(cmd *cobra.Command) {
+	cmd.Flags().String("depends-on", "", "Set task dependencies (comma-separated UUIDs)")
+}
+
+func addParentFlag(cmd *cobra.Command) {
+	cmd.Flags().String("parent", "", "Set parent task UUID")
+}
+
+func addOutputFlags(cmd *cobra.Command) {
+	cmd.Flags().String("format", "detailed", "Output format (detailed, brief)")
+	cmd.Flags().Bool("json", false, "Output as JSON")
+	cmd.Flags().Bool("no-metadata", false, "Hide creation/modification timestamps")
+}
+
+func addDueDateFlag(cmd *cobra.Command) {
+	cmd.Flags().StringP("due", "d", "", "Set due date (YYYY-MM-DD)")
+}

cmd/task_flags_test.go

···
+package main
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func TestTaskFlags(t *testing.T) {
+	t.Run("AddCommonTaskFlags", func(t *testing.T) {
+		cmd := &cobra.Command{}
+		addCommonTaskFlags(cmd)
+
+		if cmd.Flags().Lookup("priority") == nil {
+			t.Error("Expected priority flag to be defined")
+		}
+		if cmd.Flags().Lookup("project") == nil {
+			t.Error("Expected project flag to be defined")
+		}
+		if cmd.Flags().Lookup("context") == nil {
+			t.Error("Expected context flag to be defined")
+		}
+		if cmd.Flags().Lookup("tags") == nil {
+			t.Error("Expected tags flag to be defined")
+		}
+
+		if cmd.Flags().ShorthandLookup("p") == nil {
+			t.Error("Expected 'p' shorthand for priority")
+		}
+		if cmd.Flags().ShorthandLookup("c") == nil {
+			t.Error("Expected 'c' shorthand for context")
+		}
+		if cmd.Flags().ShorthandLookup("t") == nil {
+			t.Error("Expected 't' shorthand for tags")
+		}
+	})
+
+	t.Run("AddRecurrenceFlags", func(t *testing.T) {
+		cmd := &cobra.Command{}
+		addRecurrenceFlags(cmd)
+
+		if cmd.Flags().Lookup("recur") == nil {
+			t.Error("Expected recur flag to be defined")
+		}
+		if cmd.Flags().Lookup("until") == nil {
+			t.Error("Expected until flag to be defined")
+		}
+	})
+
+	t.Run("AddDependencyFlags", func(t *testing.T) {
+		cmd := &cobra.Command{}
+		addDependencyFlags(cmd)
+
+		if cmd.Flags().Lookup("depends-on") == nil {
+			t.Error("Expected depends-on flag to be defined")
+		}
+	})
+
+	t.Run("AddParentFlag", func(t *testing.T) {
+		cmd := &cobra.Command{}
+		addParentFlag(cmd)
+
+		if cmd.Flags().Lookup("parent") == nil {
+			t.Error("Expected parent flag to be defined")
+		}
+	})
+
+	t.Run("AddOutputFlags", func(t *testing.T) {
+		cmd := &cobra.Command{}
+		addOutputFlags(cmd)
+
+		if cmd.Flags().Lookup("format") == nil {
+			t.Error("Expected format flag to be defined")
+		}
+		if cmd.Flags().Lookup("json") == nil {
+			t.Error("Expected json flag to be defined")
+		}
+		if cmd.Flags().Lookup("no-metadata") == nil {
+			t.Error("Expected no-metadata flag to be defined")
+		}
+
+		format, _ := cmd.Flags().GetString("format")
+		if format != "detailed" {
+			t.Errorf("Expected format default to be 'detailed', got '%s'", format)
+		}
+	})
+
+	t.Run("AddDueDateFlag", func(t *testing.T) {
+		cmd := &cobra.Command{}
+		addDueDateFlag(cmd)
+
+		if cmd.Flags().Lookup("due") == nil {
+			t.Error("Expected due flag to be defined")
+		}
+
+		if cmd.Flags().ShorthandLookup("d") == nil {
+			t.Error("Expected 'd' shorthand for due")
+		}
+	})
+}

docs/manual/noteleaf.1.txt

···
                 -d, --days <n>             Number of days (default 7)
                 -t, --task <id>            Timesheet for specific task
 
+        noteleaf task recur set <id>
+            Set recurrence rule for a task.
+            Flags:
+                --rule <value>             Recurrence rule (e.g., FREQ=DAILY)
+                --until YYYY-MM-DD         Recurrence end date
+
+        noteleaf task recur clear <id>
+            Clear recurrence rule from a task.
+
+        noteleaf task recur show <id>
+            Show recurrence details for a task.
+
+        noteleaf task depend add <id> <depends-on-uuid>
+            Add a dependency to a task.
+
+        noteleaf task depend remove <id> <depends-on-uuid>
+            Remove a dependency from a task.
+            Alias: rm
+
+        noteleaf task depend list <id>
+            List dependencies for a task.
+            Alias: ls
+
+        noteleaf task depend blocked-by <id>
+            Show tasks blocked by this task.
+
     MOVIE COMMANDS
         noteleaf movie add [query...]
             Search and add a movie to the watch queue.
···
     Save an article:
         noteleaf article add https://example.com/post
         noteleaf article list --author "Ada Lovelace"
+
+    Manage task recurrence:
+        noteleaf task recur set 42 --rule FREQ=DAILY --until 2025-12-31
+        noteleaf task recur show 42
+        noteleaf task recur clear 42
+
+    Manage task dependencies:
+        noteleaf task depend add 42 abc123-uuid
+        noteleaf task depend list 42
+        noteleaf task depend blocked-by abc123-uuid
+        noteleaf task depend remove 42 abc123-uuid
 
 FILES
     (TODO: configuration and data file paths once implemented)

internal/handlers/tasks.go

···
 		task.Tags = removeString(task.Tags, tag)
 	}
 
-	// Handle dependency additions
 	if addDeps != "" {
-		deps := strings.Split(addDeps, ",")
-		for _, dep := range deps {
+		deps := strings.SplitSeq(addDeps, ",")
+		for dep := range deps {
 			dep = strings.TrimSpace(dep)
 			if dep != "" && !slices.Contains(task.DependsOn, dep) {
 				task.DependsOn = append(task.DependsOn, dep)
···
 		}
 	}
 
-	// Handle dependency removals
 	if removeDeps != "" {
-		deps := strings.Split(removeDeps, ",")
-		for _, dep := range deps {
+		deps := strings.SplitSeq(removeDeps, ",")
+		for dep := range deps {
 			dep = strings.TrimSpace(dep)
 			task.DependsOn = removeString(task.DependsOn, dep)
 		}
···
 		return fmt.Errorf("failed to marshal task to JSON: %w", err)
 	}
 	fmt.Println(string(jsonData))
+	return nil
+}
+
+// SetRecur sets the recurrence rule for a task
+func (h *TaskHandler) SetRecur(ctx context.Context, taskID, rule, until string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	if rule != "" {
+		task.Recur = models.RRule(rule)
+	}
+
+	if until != "" {
+		if untilTime, err := time.Parse("2006-01-02", until); err == nil {
+			task.Until = &untilTime
+		} else {
+			return fmt.Errorf("invalid until date format, use YYYY-MM-DD: %w", err)
+		}
+	}
+
+	err = h.repos.Tasks.Update(ctx, task)
+	if err != nil {
+		return fmt.Errorf("failed to update task recurrence: %w", err)
+	}
+
+	fmt.Printf("Recurrence set for task (ID: %d): %s\n", task.ID, task.Description)
+	if task.Recur != "" {
+		fmt.Printf("Rule: %s\n", task.Recur)
+	}
+	if task.Until != nil {
+		fmt.Printf("Until: %s\n", task.Until.Format("2006-01-02"))
+	}
+
+	return nil
+}
+
+// ClearRecur clears the recurrence rule from a task
+func (h *TaskHandler) ClearRecur(ctx context.Context, taskID string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	task.Recur = ""
+	task.Until = nil
+
+	err = h.repos.Tasks.Update(ctx, task)
+	if err != nil {
+		return fmt.Errorf("failed to clear task recurrence: %w", err)
+	}
+
+	fmt.Printf("Recurrence cleared for task (ID: %d): %s\n", task.ID, task.Description)
+	return nil
+}
+
+// ShowRecur displays the recurrence details for a task
+func (h *TaskHandler) ShowRecur(ctx context.Context, taskID string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	fmt.Printf("Task (ID: %d): %s\n", task.ID, task.Description)
+	if task.Recur != "" {
+		fmt.Printf("Recurrence rule: %s\n", task.Recur)
+		if task.Until != nil {
+			fmt.Printf("Recurrence until: %s\n", task.Until.Format("2006-01-02"))
+		} else {
+			fmt.Printf("Recurrence until: (no end date)\n")
+		}
+	} else {
+		fmt.Printf("No recurrence set\n")
+	}
+
+	return nil
+}
+
+// AddDep adds a dependency to a task
+func (h *TaskHandler) AddDep(ctx context.Context, taskID, dependsOnUUID string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	if _, err := h.repos.Tasks.GetByUUID(ctx, dependsOnUUID); err != nil {
+		return fmt.Errorf("dependency task not found: %w", err)
+	}
+
+	err = h.repos.Tasks.AddDependency(ctx, task.UUID, dependsOnUUID)
+	if err != nil {
+		return fmt.Errorf("failed to add dependency: %w", err)
+	}
+
+	fmt.Printf("Dependency added to task (ID: %d): %s\n", task.ID, task.Description)
+	fmt.Printf("Now depends on: %s\n", dependsOnUUID)
+
+	return nil
+}
+
+// RemoveDep removes a dependency from a task
+func (h *TaskHandler) RemoveDep(ctx context.Context, taskID, dependsOnUUID string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	err = h.repos.Tasks.RemoveDependency(ctx, task.UUID, dependsOnUUID)
+	if err != nil {
+		return fmt.Errorf("failed to remove dependency: %w", err)
+	}
+
+	fmt.Printf("Dependency removed from task (ID: %d): %s\n", task.ID, task.Description)
+	fmt.Printf("No longer depends on: %s\n", dependsOnUUID)
+
+	return nil
+}
+
+// ListDeps lists all dependencies for a task
+func (h *TaskHandler) ListDeps(ctx context.Context, taskID string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	fmt.Printf("Task (ID: %d): %s\n", task.ID, task.Description)
+
+	if len(task.DependsOn) == 0 {
+		fmt.Printf("No dependencies\n")
+		return nil
+	}
+
+	fmt.Printf("Depends on %d task(s):\n", len(task.DependsOn))
+	for _, depUUID := range task.DependsOn {
+		depTask, err := h.repos.Tasks.GetByUUID(ctx, depUUID)
+		if err != nil {
+			fmt.Printf("  - %s (not found)\n", depUUID)
+			continue
+		}
+		fmt.Printf("  - [%d] %s (UUID: %s)\n", depTask.ID, depTask.Description, depTask.UUID)
+	}
+
+	return nil
+}
+
+// BlockedByDep shows tasks that are blocked by the given task
+func (h *TaskHandler) BlockedByDep(ctx context.Context, taskID string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	fmt.Printf("Task (ID: %d): %s\n", task.ID, task.Description)
+
+	dependents, err := h.repos.Tasks.GetDependents(ctx, task.UUID)
+	if err != nil {
+		return fmt.Errorf("failed to get dependent tasks: %w", err)
+	}
+
+	if len(dependents) == 0 {
+		fmt.Printf("No tasks are blocked by this task\n")
+		return nil
+	}
+
+	fmt.Printf("Blocks %d task(s):\n", len(dependents))
+	for _, dep := range dependents {
+		fmt.Printf("  - [%d] %s\n", dep.ID, dep.Description)
+	}
+
 	return nil
 }
 

internal/handlers/tasks_test.go

···
 		defer handler.Close()
 
 		tasks := []*models.Task{
-			{
-				UUID:        uuid.New().String(),
-				Description: "Task with context 1",
-				Status:      "pending",
-				Context:     "test-context",
-			},
-			{
-				UUID:        uuid.New().String(),
-				Description: "Task with context 2",
-				Status:      "pending",
-				Context:     "work-context",
-			},
-			{
-				UUID:        uuid.New().String(),
-				Description: "Task without context",
-				Status:      "pending",
-			},
+			{UUID: uuid.New().String(), Description: "Task with context 1", Status: "pending", Context: "test-context"},
+			{UUID: uuid.New().String(), Description: "Task with context 2", Status: "pending", Context: "work-context"},
+			{UUID: uuid.New().String(), Description: "Task without context", Status: "pending"},
 		}
 
 		for _, task := range tasks {
···
 				t.Errorf("ListContexts with no contexts failed: %v", err)
 			}
 		})
+	})
+
+	t.Run("RecurSet", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		id, err := handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID: uuid.New().String(), Description: "Test task", Status: "pending",
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+
+		t.Run("sets recurrence rule", func(t *testing.T) {
+			err := handler.SetRecur(ctx, strconv.FormatInt(id, 10), "FREQ=DAILY", "2025-12-31")
+			if err != nil {
+				t.Errorf("RecurSet failed: %v", err)
+			}
+
+			task, err := handler.repos.Tasks.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get task: %v", err)
+			}
+
+			if task.Recur != "FREQ=DAILY" {
+				t.Errorf("Expected recur to be 'FREQ=DAILY', got '%s'", task.Recur)
+			}
+
+			if task.Until == nil {
+				t.Error("Expected until to be set")
+			}
+		})
+
+		t.Run("handles invalid until date", func(t *testing.T) {
+			err := handler.SetRecur(ctx, strconv.FormatInt(id, 10), "FREQ=WEEKLY", "invalid-date")
+			if err == nil {
+				t.Error("Expected error for invalid until date")
+			}
+		})
+	})
+
+	t.Run("RecurClear", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		until := time.Now()
+		id, err := handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Test task",
+			Status:      "pending",
+			Recur:       "FREQ=DAILY",
+			Until:       &until,
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+
+		err = handler.ClearRecur(ctx, strconv.FormatInt(id, 10))
+		if err != nil {
+			t.Errorf("RecurClear failed: %v", err)
+		}
+
+		task, err := handler.repos.Tasks.Get(ctx, id)
+		if err != nil {
+			t.Fatalf("Failed to get task: %v", err)
+		}
+
+		if task.Recur != "" {
+			t.Errorf("Expected recur to be cleared, got '%s'", task.Recur)
+		}
+
+		if task.Until != nil {
+			t.Error("Expected until to be cleared")
+		}
+	})
+
+	t.Run("RecurShow", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		until := time.Now()
+		id, err := handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Test task",
+			Status:      "pending",
+			Recur:       "FREQ=DAILY",
+			Until:       &until,
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
+		}
+
+		err = handler.ShowRecur(ctx, strconv.FormatInt(id, 10))
+		if err != nil {
+			t.Errorf("RecurShow failed: %v", err)
+		}
+	})
+
+	t.Run("DependAdd", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		task1UUID := uuid.New().String()
+		task2UUID := uuid.New().String()
+
+		id1, err := handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID: task1UUID, Description: "Task 1", Status: "pending",
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 1: %v", err)
+		}
+
+		_, err = handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID: task2UUID, Description: "Task 2", Status: "pending",
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 2: %v", err)
+		}
+
+		err = handler.AddDep(ctx, strconv.FormatInt(id1, 10), task2UUID)
+		if err != nil {
+			t.Errorf("DependAdd failed: %v", err)
+		}
+
+		task, err := handler.repos.Tasks.Get(ctx, id1)
+		if err != nil {
+			t.Fatalf("Failed to get task: %v", err)
+		}
+
+		if len(task.DependsOn) != 1 {
+			t.Errorf("Expected 1 dependency, got %d", len(task.DependsOn))
+		}
+
+		if task.DependsOn[0] != task2UUID {
+			t.Errorf("Expected dependency to be '%s', got '%s'", task2UUID, task.DependsOn[0])
+		}
+	})
+
+	t.Run("DependRemove", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		task1UUID := uuid.New().String()
+		task2UUID := uuid.New().String()
+
+		_, err = handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID: task2UUID, Description: "Task 2", Status: "pending",
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 2: %v", err)
+		}
+
+		id1, err := handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID:        task1UUID,
+			Description: "Task 1",
+			Status:      "pending",
+			DependsOn:   []string{task2UUID},
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 1: %v", err)
+		}
+
+		err = handler.RemoveDep(ctx, strconv.FormatInt(id1, 10), task2UUID)
+		if err != nil {
+			t.Errorf("DependRemove failed: %v", err)
+		}
+
+		task, err := handler.repos.Tasks.Get(ctx, id1)
+		if err != nil {
+			t.Fatalf("Failed to get task: %v", err)
+		}
+
+		if len(task.DependsOn) != 0 {
+			t.Errorf("Expected 0 dependencies, got %d", len(task.DependsOn))
+		}
+	})
+
+	t.Run("DependList", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		task1UUID := uuid.New().String()
+		task2UUID := uuid.New().String()
+
+		_, err = handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID: task2UUID, Description: "Task 2", Status: "pending",
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 2: %v", err)
+		}
+
+		id1, err := handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID:        task1UUID,
+			Description: "Task 1",
+			Status:      "pending",
+			DependsOn:   []string{task2UUID},
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 1: %v", err)
+		}
+
+		err = handler.ListDeps(ctx, strconv.FormatInt(id1, 10))
+		if err != nil {
+			t.Errorf("DependList failed: %v", err)
+		}
+	})
+
+	t.Run("DependBlockedBy", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		task1UUID := uuid.New().String()
+		task2UUID := uuid.New().String()
+
+		id2, err := handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID: task2UUID, Description: "Task 2", Status: "pending",
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 2: %v", err)
+		}
+
+		_, err = handler.repos.Tasks.Create(ctx, &models.Task{
+			UUID:        task1UUID,
+			Description: "Task 1",
+			Status:      "pending",
+			DependsOn:   []string{task2UUID},
+		})
+		if err != nil {
+			t.Fatalf("Failed to create task 1: %v", err)
+		}
+
+		err = handler.BlockedByDep(ctx, strconv.FormatInt(id2, 10))
+		if err != nil {
+			t.Errorf("DependBlockedBy failed: %v", err)
+		}
 	})
 }