On the first thought it looks like a good idea, but when you take your time and try imagining the use cases and the abuse people tend to achieve via extending classes - it get’s messy.
Just picture this:
A person makes an extension - fairly simple, not much functionality, but it works and has it’s major use cases covered.
Time goes by and someone has a need to extend it. No problem, extend the damn thing and add desired functionality. Fairly simple.
Some time goes by and other person has a big chunk of functionality written over the second extended version and changes some inner working by overriding methods a little because the base does not handle the increased complexity. The thing gets heavy and now is 3 layers deep (not counting inner layers of extending there may be).
Eventually some one will extend it even further, but I would like to believe that there will be no such foolish enough person to do that (still the believer to the end, yes).
So in the end we end up with multiple versions of stuff that is layered on each other. One day the original author just rewrites the damn thing and all other have to do it all over again. That’s why I think it’s a bad idea in general.
On the bright note, if there is an official repository with solid stable extensions, that guarantee that they do not change their API at least until framework changes it’s minor versions (2.0, 2.1, …, 2.n) - it will give people a solid platform. But this should be closely monitored and extensions should go in only after some extended period of existence and development to make them stable.