fix: hanging tests

cmd/commands.go

···
 		},
 	})
 
-	root.AddCommand(&cobra.Command{
+	projectsCmd := &cobra.Command{
 		Use:     "projects",
 		Short:   "List projects",
 		Aliases: []string{"proj"},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.ListProjects(cmd.Context(), args)
+			static, _ := cmd.Flags().GetBool("static")
+			return handlers.ListProjects(cmd.Context(), static)
 		},
-	})
+	}
+	projectsCmd.Flags().Bool("static", false, "Use static text output instead of interactive")
+	root.AddCommand(projectsCmd)
 
-	root.AddCommand(&cobra.Command{
+	tagsCmd := &cobra.Command{
 		Use:     "tags",
 		Short:   "List tags",
 		Aliases: []string{"t"},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.ListTags(cmd.Context(), args)
+			static, _ := cmd.Flags().GetBool("static")
+			return handlers.ListTags(cmd.Context(), static)
 		},
-	})
+	}
+	tagsCmd.Flags().Bool("static", false, "Use static text output instead of interactive")
+	root.AddCommand(tagsCmd)
 
 	root.AddCommand(&cobra.Command{
 		Use:     "contexts",

internal/handlers/tasks.go

···
 		Project:  project,
 	}
 
-	// Default to showing pending tasks only unless --all is specified
 	if !showAll && opts.Status == "" {
 		opts.Status = "pending"
 	}
···
 }
 
 // ListProjects lists all projects with their task counts
-func ListProjects(ctx context.Context, args []string) error {
+func ListProjects(ctx context.Context, static bool) error {
 	handler, err := NewTaskHandler()
 	if err != nil {
 		return fmt.Errorf("failed to initialize task handler: %w", err)
 	}
 	defer handler.Close()
 
-	return handler.listProjects(ctx)
+	if static {
+		return handler.listProjectsStatic(ctx)
+	}
+
+	return handler.listProjectsInteractive(ctx)
+}
+
+func (h *TaskHandler) listProjectsStatic(ctx context.Context) error {
+	tasks, err := h.repos.Tasks.List(ctx, repo.TaskListOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list tasks for projects: %w", err)
+	}
+
+	projectCounts := make(map[string]int)
+	for _, task := range tasks {
+		if task.Project != "" {
+			projectCounts[task.Project]++
+		}
+	}
+
+	if len(projectCounts) == 0 {
+		fmt.Printf("No projects found\n")
+		return nil
+	}
+
+	projects := make([]string, 0, len(projectCounts))
+	for project := range projectCounts {
+		projects = append(projects, project)
+	}
+	slices.Sort(projects)
+
+	fmt.Printf("Found %d project(s):\n\n", len(projects))
+	for _, project := range projects {
+		count := projectCounts[project]
+		fmt.Printf("%s (%d task%s)\n", project, count, pluralize(count))
+	}
+
+	return nil
 }
 
-func (h *TaskHandler) listProjects(ctx context.Context) error {
+func (h *TaskHandler) listProjectsInteractive(ctx context.Context) error {
 	projectList := ui.NewProjectList(h.repos.Tasks, ui.ProjectListOptions{})
 	return projectList.Browse(ctx)
 }
 
 // ListTags lists all tags with their task counts
-func ListTags(ctx context.Context, args []string) error {
+func ListTags(ctx context.Context, static bool) error {
 	handler, err := NewTaskHandler()
 	if err != nil {
 		return fmt.Errorf("failed to initialize task handler: %w", err)
 	}
 	defer handler.Close()
 
-	return handler.listTags(ctx)
+	if static {
+		return handler.listTagsStatic(ctx)
+	}
+
+	return handler.listTagsInteractive(ctx)
+}
+
+func (h *TaskHandler) listTagsStatic(ctx context.Context) error {
+	tasks, err := h.repos.Tasks.List(ctx, repo.TaskListOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list tasks for tags: %w", err)
+	}
+
+	tagCounts := make(map[string]int)
+	for _, task := range tasks {
+		for _, tag := range task.Tags {
+			tagCounts[tag]++
+		}
+	}
+
+	if len(tagCounts) == 0 {
+		fmt.Printf("No tags found\n")
+		return nil
+	}
+
+	tags := make([]string, 0, len(tagCounts))
+	for tag := range tagCounts {
+		tags = append(tags, tag)
+	}
+	slices.Sort(tags)
+
+	fmt.Printf("Found %d tag(s):\n\n", len(tags))
+	for _, tag := range tags {
+		count := tagCounts[tag]
+		fmt.Printf("%s (%d task%s)\n", tag, count, pluralize(count))
+	}
+
+	return nil
 }
 
-func (h *TaskHandler) listTags(ctx context.Context) error {
+func (h *TaskHandler) listTagsInteractive(ctx context.Context) error {
 	tagList := ui.NewTagList(h.repos.Tasks, ui.TagListOptions{})
 	return tagList.Browse(ctx)
 }

internal/handlers/tasks_test.go

···
 		}
 
 		t.Run("lists projects successfully", func(t *testing.T) {
-			err := ListProjects(ctx, []string{})
+			err := ListProjects(ctx, true)
 			if err != nil {
 				t.Errorf("ListProjects failed: %v", err)
 			}
···
 			_, cleanup2 := setupTaskTest(t)
 			defer cleanup2()
 
-			err := ListProjects(ctx, []string{})
+			err := ListProjects(ctx, true)
 			if err != nil {
 				t.Errorf("ListProjects with no projects failed: %v", err)
 			}
···
 		}
 
 		t.Run("lists tags successfully", func(t *testing.T) {
-			err := ListTags(ctx, []string{})
+			err := ListTags(ctx, true)
 			if err != nil {
 				t.Errorf("ListTags failed: %v", err)
 			}
···
 			_, cleanup2 := setupTaskTest(t)
 			defer cleanup2()
 
-			err := ListTags(ctx, []string{})
+			err := ListTags(ctx, true)
 			if err != nil {
 				t.Errorf("ListTags with no tags failed: %v", err)
 			}

internal/ui/task_list_test.go

···
 		if !strings.Contains(output, "Plan vacation itinerary") {
 			t.Error("Second task not displayed")
 		}
-		// Should not show completed task by default
 		if strings.Contains(output, "Fix authentication bug") {
 			t.Error("Completed task should not be shown by default")
 		}

internal/ui/ui_test.go

···
 			withColor(t, func(r *lipgloss.Renderer) {
 				logo := Colossal
 				viewport := logo.ColoredInViewport(r)
-				t.Logf("viewport output:\n%s", viewport)
 
 				if viewport == "" {
 					t.Fatal("viewport is empty")