SteveChallender's answer is good, and I upvoted it. (Remember, upvoting stands for "this answer is useful".) However, in your case it might represent a bit of over-engineering. You are the one who really knows, and therefore the one who judges whether it is so, I am simply pointing out the possibility that it might be so.
Here is my input on the three possibilities that you listed:
- I could add the methods to the original class, but the class will get very bloated.
This could very possibly be your best choice. Lately I have been noticing that many programmers are totally frightened by sheer line counts. Someone reviewing my code once called a 250-line class of mine "awfully long". The poor guy has not seen some 2500-line classes that I have. Here is the thing: if the class is really doing just one thing, and if there is no internal structure in it, (no disjoint sets of internal state used by different groups of methods,) if the methods are simply doing stuff invoking other methods, then they truly all belong to the same class. It is just a fact of life. It is a huge mistake to add unnecessary additional structure to your system's design only in order to reduce the number of lines of an otherwise perfectly fine class, just because the number of lines in that class exceeds some blind preconceptions about what a good number of lines should be. Remember, "Things should be as simple as possible, but not simpler." (A. Einstein.) And that's because if you try and make them "simpler than possible" then you are practically guaranteed that you will actually end up making them more complicated.
- I could write a module of just functions, but they would always need that class an argument.
Yes, that would not be a very smart thing to do. A large number of functions which all accept a specific class as an argument is in fact a large number of functions screaming "put us in that class!" or at worst, "put us in a class, and make that object a member of that class, so we know where to find it!"
- I could inherit and make a new class: MoreSpecificClass.
Making functionality available to different subsets of code is one of the least legitimate reasons for using inheritance. You should use inheritance if your MoreSpecificClass has an "is a" relationship with your LessSpecificClass. Will it have such a relationship? Will you ever have a function which accepts "LessSpecificClass" as an argument and be in the need to pass a "MoreSpecificClass" instead? I doubt that you are planning to do such a thing, so I doubt that inheritance is suitable here.