I've made the following hook that does that simple implementation.

# hook version 2
def hook_autocomplete(self, params: cmd2.plugin.PostparsingData) -> cmd2.plugin.PostparsingData:

    func = self.cmd_func(params.statement.command)
    if not func:
        basecmd = self.complete(params.statement.command, 0)
        nextcmd = self.complete(params.statement.command, 1)
        if(basecmd is not None and nextcmd is None):
            basecmd = basecmd[:-1]
            params.statement = Statement(params.statement.args,
                                         raw=params.statement.raw,
                                         command=basecmd,
                                         arg_list=params.statement.arg_list,
                                         multiline_command=params.statement.multiline_command,
                                         terminator=params.statement.terminator,
                                         suffix=params.statement.suffix,
                                         pipe_to=params.statement.pipe_to,
                                         output=params.statement.output,
                                         output_to=params.statement.output_to)

    return params

Seems to works great but It should also support concatenations of partial commands.
Example: we have a command show, with a subcomand interface... In order to fully support partial commands sh int should be an alias to show interface.

I've never actually used it but I know we have this plugin for abbreviated command support. It seems very similar to what you're describing.

https://github.com/python-cmd2/cmd2-abbrev

@ralequi Calling complete() directly to resolve subcommand names will be problematic since your hook doesn't know what tokens are intended to be subcommands. cmd2.ArgparseCompleter figures this out by parsing the command line using knowledge of the command's argparser.

Since argparse only supports abbreviation of long options names, and not subcommands, there isn't an easy way to do what you're asking without writing code to examine the tokens in the same way cmd2.ArgparseCompleter does. If you are interested in writing such an approach, look at cmd2.ArgparseCompleter.complete_subcommand_help() for guidance.

If you have a known set of aliases you'd like to use for subcommands, you can take advantage of argparse subcommand aliases.

From argparse docs

Furthermore, add_parser supports an additional aliases argument, which allows multiple strings to refer to the same subparser. This example, like svn, aliases co as a shorthand for checkout:

parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers()
checkout = subparsers.add_parser('checkout', aliases=['co'])
checkout.add_argument('foo')
parser.parse_args(['co', 'bar'])

cmd2.ArgparseCompleter supports subcommand aliases as well, so they will tab complete.

Thanks for your replies guys,

@anselor that plugin looks great but it seems to do something like I did in that hook. It should work great but unless I'm missing something it would have the same limitation that my hook has, as far as it should not be able to autocomplete sub-commands.

Thanks @kmvanbrunt , I supposed a simple hook won't be able to do what I wish. I have to finish some basic functionality on my APP, but I consider this feature very powerful (and mostly required to my clients, as they come from managing cisco/juniper like devices) so I'll look forward to it when I finish that basic func.