Short answer: you're not forced to release your software under GPL; you can do it because you're making interoperability with GPL software and this doesn't make your software a derivative work (but if you want to feel more safe then don't distribute Git inside your application package, a dependency is OK).
Dirty workaround to avoid licensing headaches: note that if you make your package independent from Git and you have a separated Source Control Integration Layer then you may want to release under GPL (with source code on GitHub?!) only your Git integration module (not whole software which, in theory, is abstracted and compatible with any SCM).
Note that this question has been asked before: Can I use GPL software in a commercial application? but I completely disagree with given accepted answer and I'll try to explain why. GPL needs to overprotect itself to avoid abuses and misuses but its bounds are set by law and it can't prevaricate them.
Long answer: it's a common debate about GPL, you'll find both point of views (it's derivative work or it's not). I'm not a lawyer (and this issue has been disccused in a court too few times to have a well-known universally accepted answer) but let's try to summarize.
GPL ties you to distribute your source code if you deploy any derivative work based on GPL. First of all check if Git has a GPL linking exception (in that case you can freely use it). Main point is then to define derivative work. What they say about this (quotation from FAQ)?
If the program dynamically links plug-ins, and they make function calls to each other and share data structures, we believe they form a single program, which must be treated as an extension of both the main program and the plug-ins. This means the plug-ins must be released under the GPL or a GPL-compatible free software license, and that the terms of the GPL must be followed when those plug-ins are distributed.
For US law derivative work is:
“derivative work” is a work based upon one or more pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which a work may be recast, transformed, or adapted.
How you define transformed and adapted from copyright point of view (in US law)?
This previously published material makes the work a derivative work under the copyright law. To be copyrightable, a derivative work must be different enough from the original to be regarded as a “new work” or must contain a substantial amount of new material. Making minor changes or additions of little substance to a preexisting work will not qualify the work as a new version for copyright purposes.
You have to incorporate GPL material in your own application. To use it is not enough to define your work as derivative. If you think about it then this is pretty obvious (and important!) because if you use Git to manage your source code you don't need to release your application under GPL!
Moreover they also says that:
Titles, short phrases, and format, for example, are not copyrightable
Then now you also know that you have to include enough GPL material in your own work. A code snippet copied & pasted in your own code doesn't make it tied to GPL.
It seems that US law and GPL agree about derivative work but note that GPL is much more specific: they explicitly say they make functions calls [...] and share data structures. If you include
git.exe in your program then you're not making any function call. It's (in theory) perfectly allowed by GPL license.
In fact they later explicitly says that:
If the program dynamically links plug-ins, but the communication between them is limited to invoking the ‘main’ function of the plug-in with some options and waiting for it to return, that is a borderline case.
Also note that they generically speak about plugin so it may be applied also to dynamic linked libraries where you invoke just one function (although IMO it should also be the only exported function).
Dependent code is not derivative code, interoperability doesn't make your code a derivative work. There is even sentence from an US court for a similar issue: Lewis Galoob Toys, Inc. v. Nintendo of America, Inc..
Note that they also say:
If the program uses fork and exec to invoke plug-ins, then the plug-ins are separate programs, so the license for the main program makes no requirements for them.
There is no mention about deployment method (one single package or a dependency).
According to GPL license you're in doubt but according to US law you have to incorporate GPL material to be tied to GPL license. You can do it without any problem but if you want to feel more safe then make it a dependency (installed together with your package or a mandatory prerequisite),
Given all these hard reasoning then:
non-GPL application calls a GPL application at the command line -> definitely legal
Yes, if connection between your code and Git takes place at user's computer then you're not restricted by GPL in any way.
non-GPL application links to a GPL application using function calls -> definitely illegal
Maybe not. If you invoke just one main plugin function then it may be a borderline case which IMO should be avoided because contrary to GPL spirit. If you don't like just don't use it.
non-GPL application bundles, distributes, and calls a GPL application at the command line -> ?
Legal, dependent code is not derivative code and interoperability doesn't make your code a derivative work. Moreover they explicitly states that if you use
exec then it's not derivative or combined work (no mention about deployment).
From Scott's link a lawyer explains this issue with much deeper knowledge and better wording, I'd like to highlight one passage from that article (emphasis is mine):
The phrase, "This General Public License does not permit incorporating your program into proprietary programs", comes after the "END OF TERMS AND CONDITIONS" statement. It is not part of the license itself. In any case, the statement is not supported by the text of the license. The GPL does not prohibit incorporating proprietary programs; at best, it requires that proprietary programs be subject to the GPL's inheritance obligations.
Also re-read dirty workaround I suggested at beginning if you want to feel safe.