Powershell: autocomplete for tools

[Meir017]

I really like the ability to call any tool from powershell.

It would be nice to have autocomplete when using exe's whithin a powershell script

for example:

git clone https://github.com/PowerShell/PowerShell.git -branch master
it would be nice it after typeing git clone https://github.com/PowerShell/PowerShell.git - and tab it would complete to branch (or another option).

A possible implementation could be to create wrapper functions for each exe methods.

for example:
````ps1
function git-clone {
param(
[ValidatePattern('(?:git|ssh|https?|git@[\w.]+):(?:\/\/)?[\w.@:\/~_-]+.git(?:\/?|#[\d\w.-_]+?)')]
[Parameter(Mandatory=$True, ValueFromPipeline)]
[string]$giturl,

    [alias('b')]
    [string]$branch
)

$expression = "git clone $giturl"

if($branch){
    $expression += " -branch $branch"
}

if($noHardlinks){
    $expression += ' --no-hardlinks'
}

#Invoke-Expression $expression

}
````

this could be a project like https://github.com/DefinitelyTyped/DefinitelyTyped that is used just for autocomplete

[rkeithhill]

See https://github.com/lzybkr/TabExpansionPlusPlus/. And for Git specifically, checkout the posh-git module. It is in the PowerShell Gallery and at https://github.com/dahlbyk/posh-git. Wait for 0.7.0 to release though. Should be out by the end of the week.

Also see this enh req: https://github.com/dahlbyk/posh-git/issues/257

[Meir017]

I didn't totally understand how this works but it seams to me like this is for more advanced scenarios where I would want to have autocomplete based on used parameters and more, instead of having the same completions for the command no matter what.

The learning curve for a wrapper for an exe is extremely low since the only thing needed is to go over the exe's available parameters.

[joeyaiello]

@Meir017 I think you're looking for TabExpansionPlusPlus here. I don't think it makes a lot of sense for PowerShell itself to go implementing all native EXE parameters: even we wanted to maintain a massive database of all native binary parameters (we don't), many are contextual anyway (the problem posh-git and TE++ work to solve).

That being said, I know I've briefly discussed with @lzybkr the possibility of parsing man pages on Linux to provide some automated propagation of IntelliSense (which would be really cool with PSReadline Tooltips that show the description, or in VS Code, but I don't think anyone is planning to do that work any time soon.

[powercode]

I did that for git, i.e. scraped the html pages of the help and generated the completions for the common commands.

But there will always be manual work to figure out the contextual completion that is needed to make completion really useful.

https://github.com/powercode/PSGitCompletions

[iSazonov]

Makes no sense to maintain a massive database of all native binary parameters but perhaps it makes sense to think about how to provide a simple mechanism for third-party providers to add their own additions to Intellisense by means of .ps1xml and .psd1.

It would also be good to have a standard for the description of the parameters through a APIs or/and manifests. Then we could get everything we need in the native way on both platforms.

[lzybkr]

I think the best we can hope for is something like this.

The idea here is to have a framework for command line tools that is capable of generating completions for your favorite shell, and then get everybody using your library.

This might be sufficient for many tools, but it would still require lots of work for advanced uses like completing branch names for git.

[mpawelski]

I think sufficient enough and pretty cool option would be if we had some possibility to use bash scripts for tabcompletion in powershell.

There are tons of bash scrips for tab completions (for example bash_completion) and many command line tools if they provide tab completion then it's almost always at least bash (and sometimes zsh), for example, angular cli, docker-compose, npm.

I have no big experience and knowledge how bash and powershell tabcompletions works but this is the idea for implementation I had in my head:
In Register-ArgumentCompleter script block call bash and ask it what it would complete (there must some function for it) and then provide that completion to powershell. On Windows we could use WSL on linux just call bash.

[sphr2k]

It would be really helpful if PowerShell Core had support for bash-completion scripts - at least on Linux.

[SteveL-MSFT]

https://www.powershellgallery.com/packages/PSUnixUtilCompleters leverages existing bash-completers and zsh-completers. I don't think there's any additional specific work we'd do here. I would recommend contributing to TabExpansionPlusPlus for any native utils that aren't covered by bash-completers.

PSUnixUtilCompleters 0.0.2

Get parameter completion for native Unix utilities. Requires zsh or bash.