feat: run remote repo in kpm run

pkg/client/client.go

@@ -439,6 +439,31 @@ func (c *KpmClient) CompileTarPkg(tarPath string, opts *opt.CompileOptions) (*kc
 	return c.CompileWithOpts(opts)
 }
 
+// CompileGitPkg will compile the kcl package from the git url.
+func (c *KpmClient) CompileGitPkg(gitUrl, version string, opts *opt.CompileOptions) (*kcl.KCLResultList, error) {
+	// 1. Create the temporary directory to pull the tar.
+	tmpDir, err := os.MkdirTemp("", "")
+	if err != nil {
+		return nil, reporter.NewErrorEvent(reporter.Bug, err, "internal bugs, please contact us to fix it.")
+	}
+	// clean the temp dir.
+	defer os.RemoveAll(tmpDir)
+
+	// 2. clone the git repo
+	_, err = git.CloneWithOpts(
+		git.WithTag(version),
+		git.WithRepoURL(gitUrl),
+		git.WithLocalPath(tmpDir),
+	)
+	if err != nil {
+		return nil, reporter.NewErrorEvent(reporter.FailedGetPkg, err, "failed to get the git repository")
+	}
+
+	opts.SetPkgPath(tmpDir)
+
+	return c.CompileWithOpts(opts)
+}
+
 // CompileOciPkg will compile the kcl package from the OCI reference or url.
 func (c *KpmClient) CompileOciPkg(ociSource, version string, opts *opt.CompileOptions) (*kcl.KCLResultList, error) {
 	ociOpts, err := c.ParseOciOptionFromString(ociSource, version)

pkg/cmd/cmd_run.go

@@ -138,8 +138,11 @@ func KpmRun(c *cli.Context, kpmcli *client.KpmClient) error {
 				compileResult, err = kpmcli.CompileWithOpts(kclOpts)
 			}
 		} else if runEntry.IsTar() {
-			// 'kpm run' compile the package from the kcl pakcage tar.
+			// 'kpm run' compile the package from the kcl package tar.
 			compileResult, err = kpmcli.CompileTarPkg(runEntry.PackageSource(), kclOpts)
+		} else if runEntry.IsGit() {
+			// 'kpm run' compile the package from the git url
+			compileResult, err = kpmcli.CompileGitPkg(runEntry.PackageSource(), c.String(FLAG_TAG), kclOpts)
 		} else {
 			// 'kpm run' compile the package from the OCI reference or url.
 			compileResult, err = kpmcli.CompileOciPkg(runEntry.PackageSource(), c.String(FLAG_TAG), kclOpts)

pkg/constants/constants.go

@@ -9,6 +9,7 @@ const (
 	UrlEntry                             = "url"
 	RefEntry                             = "ref"
 	TarEntry                             = "tar"
+	GitEntry						     = "git"	
 	KCL_MOD                              = "kcl.mod"
 	OCI_SEPARATOR                        = ":"
 	KCL_PKG_TAR                          = "*.tar"

pkg/runner/entry.go

@@ -67,6 +67,10 @@ func (e *Entry) IsTar() bool {
 	return e.kind == constants.TarEntry
 }
 
+func (e *Entry) IsGit() bool {
+	return e.kind == constants.GitEntry
+}
+
 // IsEmpty will return true if the entry is empty.
 func (e *Entry) IsEmpty() bool {
 	return len(e.packageSource) == 0
@@ -166,6 +170,8 @@ func GetSourceKindFrom(source string) EntryKind {
 		return constants.FileEntry
 	} else if utils.IsTar(source) {
 		return constants.TarEntry
+	} else if utils.IsGitRepoUrl(source) {
+		return constants.GitEntry
 	} else if utils.IsURL(source) {
 		return constants.UrlEntry
 	} else if utils.IsRef(source) {

pkg/utils/utils.go

@@ -11,6 +11,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	goerrors "errors"
@@ -378,6 +379,12 @@ func IsURL(str string) bool {
 	return err == nil && u.Scheme != "" && u.Host != ""
 }
 
+// IsGitRepoUrl will check whether the string 'str' is a git repo url
+func IsGitRepoUrl(str string) bool {
+	r := regexp.MustCompile(`((git|ssh|http(s)?)|(git@[\w\.]+))(:(//)?)([\w\.@\:/\-~]+)(\.git)?(/)?`)
+	return r.MatchString(str)
+}
+
 // IsRef will check whether the string 'str' is a reference.
 func IsRef(str string) bool {
 	_, err := reference.ParseNormalizedNamed(str)

pkg/utils/utils_test.go

@@ -138,6 +138,29 @@ func TestIsUrl(t *testing.T) {
 	assert.Equal(t, IsURL("https://"), false)
 }
 
+func TestIsGitRepoUrl(t *testing.T) {
+	assert.Equal(t, IsGitRepoUrl("invalid url"), false)
+	assert.Equal(t, IsGitRepoUrl("ftp://github.com/user/project.git"), false)
+	assert.Equal(t, IsGitRepoUrl("https://github.com/user/project"), true)
+	assert.Equal(t, IsGitRepoUrl("[email protected]:user/project.git"), true)
+	assert.Equal(t, IsGitRepoUrl("https://github.com/user/project.git"), true)
+	assert.Equal(t, IsGitRepoUrl("https://github.com/user/project.git"), true)
+	assert.Equal(t, IsGitRepoUrl("[email protected]:user/project.git"), true)
+	assert.Equal(t, IsGitRepoUrl("https://192.168.101.127/user/project.git"), true)
+	assert.Equal(t, IsGitRepoUrl("http://192.168.101.127/user/project.git"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://[email protected]:port/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://[email protected]/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://host.xz:port/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://host.xz/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://[email protected]/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://[email protected]/~user/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://host.xz/~user/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("ssh://[email protected]/~/path/to/repo.git"), true)
+	assert.Equal(t, IsGitRepoUrl("git://host.xz/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("http://host.xz/path/to/repo.git/"), true)
+	assert.Equal(t, IsGitRepoUrl("https://host.xz/path/to/repo.git/"), true)
+}
+
 func TestIsRef(t *testing.T) {
 	assert.Equal(t, IsRef("invalid ref"), false)
 	assert.Equal(t, IsRef("ghcr.io/xxx/xxx"), true)