diff --git a/Taskfile.yml b/Taskfile.yml
index 7281702..bed5903 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -10,9 +10,11 @@ vars:
   GORUN: "{{.GOCMD}} run"
   GOTEST: "{{.GOCMD}} test -v"
   GOCOVER: "{{.GOCMD}} test -v --cover"
+  VERSION: 
+    sh: cd version/ && versionManager go version
 
-  WINDOWS_BINARY_NAME: ./release/windows/kode-starter.exe
-  LINUX_BINARY_NAME: ./release/linux/kode-starter
+  WINDOWS_BINARY_NAME: ./release/windows/{{.VERSION}}/kode-starter.exe
+  LINUX_BINARY_NAME: ./release/linux/{{.VERSION}}/kode-starter
 
 # env:
   GOOS: Linux  
diff --git a/cmdCreate/create.go b/cmdCreate/create.go
index 4f6d1cc..4d6f38a 100644
--- a/cmdCreate/create.go
+++ b/cmdCreate/create.go
@@ -18,15 +18,20 @@ import (
 
 var token, org, name, private, description string
 
+// initailize global config
+var CfgGlobal *config.Config // Declare a global variable for config
+
+func InitConfig(config *config.Config) {
+	CfgGlobal = config // Assign the passed config to the global variable
+}
+
 var CreateCmd = &cobra.Command{
 	Use:   "create",
 	Short: "Create Github project",
 	Long:  `A simple CLI app to create a startup project on Github`,
 	Run: func(cmd *cobra.Command, args []string) {
 
-		config.SetInformations(cmd, args)
-
-		err := CreateProject()
+		err := CreateProject(cmd, args)
 		if err != nil {
 			fmt.Println("Error:", err)
 			return
@@ -34,15 +39,19 @@ var CreateCmd = &cobra.Command{
 	},
 }
 
-func CreateProject() error {
+func CreateProject(cmd *cobra.Command, args []string) error {
 
 	godotenv.Load()
 
-	fmt.Printf("Token: %s\n", config.GetToken())
-	fmt.Printf("Name: %s\n", config.GetCreateName())
-	fmt.Printf("Description: %s\n", config.GetCreateDescription())
-	fmt.Printf("Private: %s\n", config.GetCreatePrivate())
-	fmt.Printf("Org: %s\n", config.GetCreateOrganisation())
+	CfgGlobal.DebugPrintConfig("Function CreateProject")
+
+	// initialize global config for command list
+	CfgGlobal.InitCmdCreate(cmd, args)
+
+	// print header if json flag is not set
+	if !CfgGlobal.GetJsonFlag() {
+		utils.PrintHeader()
+	}
 
 	// Construct POST data
 	data := structures.Project{
@@ -51,8 +60,8 @@ func CreateProject() error {
 		Private:     private == "true",
 	}
 
-	data.Name = config.GetCreateName()
-	data.Description = config.GetCreateDescription()
+	data.Name = CfgGlobal.GetCreateName()
+	data.Description = CfgGlobal.GetCreateDescription()
 
 	fmt.Println("Structure Name:" + data.Name)
 
@@ -60,9 +69,9 @@ func CreateProject() error {
 	jsonData, _ := json.Marshal(data)
 
 	req, err := http.NewRequest("POST",
-		fmt.Sprintf("%s/%s/repos", config.GetUrlApiOrgs(), config.GetCreateOrganisation()),
+		fmt.Sprintf("%s/%s/repos", CfgGlobal.GetUrlApiOrgs(), CfgGlobal.GetCreateCmd().Organisation),
 		bytes.NewBuffer(jsonData))
-	req.Header.Set("Authorization", "token "+config.GetToken())
+	req.Header.Set("Authorization", "token "+CfgGlobal.GetTokenEnv())
 	req.Header.Set("Content-Type", "application/json")
 	client := &http.Client{}
 	res, err := client.Do(req)
diff --git a/cmdEnv/envVars.go b/cmdEnv/envVars.go
index e1f11c4..94f19de 100644
--- a/cmdEnv/envVars.go
+++ b/cmdEnv/envVars.go
@@ -3,6 +3,8 @@ package cmdEnv
 import (
 	"fmt"
 	"kode-starter/config"
+	"kode-starter/configFile"
+
 	"kode-starter/utils"
 	"os"
 	"strconv"
@@ -12,56 +14,282 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// initailize global config
+var CfgGlobal *config.Config // Declare a global variable for config
+
+// init configuration for this package
+func InitConfig(config *config.Config) {
+	CfgGlobal = config // Assign the passed config to the global variable
+}
+
 var EnvCmd = &cobra.Command{
 	Use:   "env",
 	Short: "manage environment variables",
 	Long:  `A simple CLI option to manage environment variables`,
 	Run: func(cmd *cobra.Command, args []string) {
 
-		config.SetInformations(cmd, args)
+		// Start Env command
 		startEnvVar(cmd, args)
 
-		// listFlag := config.GetEnvVariablesListFlag()
-
-		// fmt.Println("listFlag: " + strconv.FormatBool(listFlag))
-
-		// fmt.Println("GetEnvVariablesListFlag: " + strconv.FormatBool(config.GetEnvVariablesListFlag()))
-
-		// if listFlag {
-		// 	printEnvVariables()
-		// }
-
-		// err := listEnvVariables()
-		// if err != nil {
-		// 	fmt.Println("Error:", err)
-		// 	return
-		// }
-
-		// if config.GetEnvVariablesFilterFlag() {
-		// 	printEnvVariablesFilter(config.GetEnvVariablesFilter())
-		// } else if config.GetEnvVariablesListFlag() {
-		// 	printEnvVariables()
-		// }
 	},
 }
 
 func startEnvVar(cmd *cobra.Command, args []string) {
 
-	config.SetInformations(cmd, args)
-	flag := config.EnvVariablesFlag
+	CfgGlobal.DebugPrintConfig("Function StartEnvVar")
 
-	// if list flag is set to true list all environment variables
-	fmt.Println("GetEnvVariablesListFlag: " + strconv.FormatBool(config.GetEnvVariablesListFlag()))
-	if flag {
-		printEnvVariables()
+	// declare map listPaths
+	var ListPaths map[string]string
+
+	// initialize command environment
+	CfgGlobal.InitCmdEnv(cmd, args)
+
+	CfgGlobal.DebugPrintConfig("Function StartEnvVar")
+
+	if CfgGlobal.GetEnvListFlag() {
+
+		if !CfgGlobal.GetJsonFlag() {
+			if CfgGlobal.GetEnvFilterFlag() {
+				fmt.Println("with filter")
+				printEnvVariablesFilter(CfgGlobal.GetEnvFilter(), CfgGlobal.GetEnvShowAllFlag())
+			} else {
+				printEnvVariables()
+			}
+		} else {
+
+			json, err := createJsonAllEnvVar(CfgGlobal.GetEnvFilter(), CfgGlobal.GetEnvShowAllFlag())
+			if err != nil {
+				fmt.Println("Error:", err)
+				return
+			}
+			fmt.Println(json)
+		}
+
+	} else if CfgGlobal.GetEnvYmlFileFlag() {
+		cfgYmlFile := configFile.LoadConfigFile(CfgGlobal)
+
+		ListCategories, err := cfgYmlFile.GetListCategory()
+		if err != nil {
+			fmt.Println("Error:", err)
+			return
+		}
+		if !CfgGlobal.GetJsonFlag() {
+			utils.PrintHeader()
+			fmt.Println("\n   L I S T   E N V   V A R S   F R O M   Y M L   F I L E   ")
+			fmt.Println(utils.CreateLine(11))
+
+			for _, category := range ListCategories {
+				// fmt.Println("Category: " + category)
+
+				ListPaths, err = cfgYmlFile.GetAllEnvironmentVariables(category)
+				if err != nil {
+					fmt.Println("Error:", err)
+					return
+				}
+
+				// if category flag is set
+				if CfgGlobal.GetEnvCategoryFlag() {
+
+					if CfgGlobal.GetEnvCategoryInfo() == category {
+						// if ListPaths is no empty
+						if len(ListPaths) > 0 {
+							fmt.Println(color.FgLightGreen.Render("\nCategory: " + category))
+							fmt.Println(utils.CreateLine(3))
+
+							// print path and value
+							nb := 1
+
+							for path, value := range ListPaths {
+								utils.PrintTreeElement(nb, path, value)
+								nb++
+							}
+						}
+					}
+				} else {
+
+					// if ListPaths is no empty
+					if len(ListPaths) > 0 {
+						fmt.Println(color.FgLightGreen.Render("\nCategory: " + category))
+						fmt.Println(utils.CreateLine(3))
+
+						// print path and value
+						nb := 1
+
+						for path, value := range ListPaths {
+							utils.PrintTreeElement(nb, path, value)
+							nb++
+						}
+					}
+
+				}
+
+			}
+			fmt.Println(utils.CreateLine(3))
+
+		} else {
+			// Execute function createJsonAllEnvVarYml : create json output for all environment variables with category
+			jsonOutput, err := createJsonAllEnvVarYml(cfgYmlFile, CfgGlobal.GetEnvCategoryInfo())
+			if err != nil {
+				fmt.Println("Error:", err)
+				return
+			}
+			fmt.Println(jsonOutput)
+		}
+
+	} else {
+		cmd.Help()
+		fmt.Println(utils.CreateLine(8))
 	}
 
 }
 
+func createJsonAllEnvVar(filter string, showAll bool) (string, error) {
+
+	//var jsonOutput string
+	jsonOutput := ""
+
+	// var map listPaths
+	ListPaths := make(map[string]string)
+
+	// var pair []string
+
+	for _, e := range os.Environ() {
+		// split key and value
+		pair := strings.Split(e, "=")
+
+		// fmt.Println(pair[1])
+		if showAll {
+			ListPaths[string(pair[0])] = string(pair[1])
+		} else {
+			if (strings.Contains(pair[0], filter)) || (strings.Contains(pair[1], filter)) {
+				ListPaths[string(pair[0])] = string(pair[1])
+			}
+		}
+
+	}
+
+	// loop over all environment variables to create json output
+	jsonOutput += "{\n"
+	for path, value := range ListPaths {
+		jsonOutput += "  \"" + path + "\": \"" + value + "\",\n"
+	}
+	jsonOutput = strings.TrimSuffix(jsonOutput, ",\n")
+	jsonOutput += "\n}\n"
+
+	return utils.DoubleBackSlash(jsonOutput), nil
+
+}
+
+// The function `createJsonAllEnvVar` creates a JSON string containing all environment variables from a
+// given configuration YAML file.
+func createJsonAllEnvVarYml(cfgYmlFile *configFile.ConfigYml, categoryInfo string) (string, error) {
+
+	//var jsonOutput string
+	jsonOutput := ""
+
+	ListCategories, err := cfgYmlFile.GetListCategory()
+	if err != nil {
+		fmt.Println("Error:", err)
+		return "", err
+	}
+
+	var isCategoryInfoPresent bool = false
+
+	// check if categoryInfo includes in ListCategories
+	for _, category := range ListCategories {
+		if category == categoryInfo {
+			isCategoryInfoPresent = true
+			break
+		}
+	}
+
+	if categoryInfo == "" {
+
+		// loop over all categories
+		jsonOutput += "{\n"
+		for _, category := range ListCategories {
+
+			ListPaths, err := cfgYmlFile.GetAllEnvironmentVariables(category)
+			if err != nil {
+				fmt.Println("Error:", err)
+				return "", err
+			}
+
+			// if ListPaths is no empty
+			if len(ListPaths) > 0 {
+
+				// add category as array and list of environment variables to jsonOutput
+
+				jsonOutput += "  \"" + category + "\": [\n"
+
+				// loop over all environment variables
+				for path, value := range ListPaths {
+					jsonOutput += "    {\n"
+					jsonOutput += "      \"" + path + "\": \"" + value + "\"\n"
+					jsonOutput += "    },\n"
+				}
+
+				// remove last comma
+				jsonOutput = strings.TrimSuffix(jsonOutput, ",\n")
+
+				jsonOutput += "\n  ],\n"
+
+			}
+
+		}
+		jsonOutput = strings.TrimSuffix(jsonOutput, ",\n")
+		jsonOutput += "\n}\n"
+
+	} else {
+
+		// loop over all categories
+		if isCategoryInfoPresent {
+			jsonOutput += "{\n"
+			for _, category := range ListCategories {
+
+				ListPaths, err := cfgYmlFile.GetAllEnvironmentVariables(category)
+				if err != nil {
+					fmt.Println("Error:", err)
+					return "", err
+				}
+
+				if category == categoryInfo {
+					// if ListPaths is no empty
+					if len(ListPaths) > 0 {
+
+						// add category as array and list of environment variables to jsonOutput
+
+						jsonOutput += "  \"" + category + "\": [\n"
+
+						// loop over all environment variables
+						for path, value := range ListPaths {
+							jsonOutput += "    {\n"
+							jsonOutput += "      \"" + path + "\": \"" + value + "\"\n"
+							jsonOutput += "    },\n"
+						}
+
+						// remove last comma
+						jsonOutput = strings.TrimSuffix(jsonOutput, ",\n")
+
+						jsonOutput += "\n  ],\n"
+
+					}
+				}
+			}
+
+			jsonOutput = strings.TrimSuffix(jsonOutput, ",\n")
+			jsonOutput += "\n}\n"
+		}
+
+	}
+	return utils.DoubleBackSlash(jsonOutput), nil
+
+}
+
 func listEnvVariables() error {
 
-	if config.GetEnvVariablesListFlag() {
-		fmt.Println("GetEnvVariablesListFlag: " + strconv.FormatBool(config.GetEnvVariablesListFlag()))
+	if CfgGlobal.GetEnvCmd().EnvVariablesFilterFlag {
+		fmt.Println("GetEnvVariablesListFlag: " + strconv.FormatBool(CfgGlobal.GetEnvCmd().EnvVariablesListFlag))
 		printEnvVariables()
 	}
 
@@ -70,33 +298,56 @@ func listEnvVariables() error {
 }
 
 func printEnvVariables() {
-	fmt.Println("Environment variables")
-	fmt.Println("---------------------")
+	fmt.Println("E n v i r o n m e n t   v a r i a b l e s")
+	fmt.Println("-----------------------------------------")
+
+	nb := 1
 
 	// loop over all environment variables
 	for _, e := range os.Environ() {
 		// split key and value
 		pair := strings.Split(e, "=")
-		fmt.Printf("%s=%s\n", pair[0], pair[1])
+		utils.PrintTreeElement(nb, pair[0], pair[1])
+		nb++
 	}
+
+	fmt.Println("-----------------------------------------")
 }
 
-func printEnvVariablesFilter(filter string) {
-	fmt.Println("Environment variables")
+func printEnvVariablesFilter(filter string, showAll bool) {
+	fmt.Println("Filter Environment variables")
 	// fmt.Println("---------------------")
 	utils.CreateLine(5)
 
+	nb := 1
+	var str2, str3 string
+	var addToPrint bool = false
+
 	// loop over all environment variables
 	for _, e := range os.Environ() {
 		// split key and value
 		pair := strings.Split(e, "=")
 		if strings.Contains(pair[0], filter) {
-			fmt.Printf("%s=%s\n", utils.ColorizeSubStrRed(pair[0], filter), color.Green.Sprint(pair[1]))
+			str2 = utils.ColorizeSubStrRed(pair[0], filter)
+			str3 = color.Green.Sprint(pair[1])
+			addToPrint = true
 		} else if strings.Contains(pair[1], filter) {
-			fmt.Printf("%s=%s\n", color.Green.Sprint(pair[0]), utils.ColorizeSubStrRed(pair[1], filter))
+			str2 = color.Green.Sprint(pair[0])
+			str3 = utils.ColorizeSubStrRed(pair[1], filter)
+			addToPrint = true
 		} else {
-			fmt.Printf("%s=%s\n", pair[0], pair[1])
+			if showAll {
+				str2 = utils.ColorizeString(pair[0], color.Green)
+				str3 = utils.ColorizeString(pair[1], color.LightWhite)
+				addToPrint = true
+			}
 		}
+		if addToPrint {
+			utils.PrintTreeElement(nb, str2, str3)
+		}
+
+		addToPrint = false
+		nb++
 
 	}
 }
diff --git a/cmdLists/gitHub.go b/cmdLists/gitHub.go
new file mode 100644
index 0000000..e135d72
--- /dev/null
+++ b/cmdLists/gitHub.go
@@ -0,0 +1,42 @@
+package cmdLists
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/go-github/github"
+	"golang.org/x/oauth2"
+)
+
+func ListGitHubOrganization() ([]string, error) {
+
+	var orgs []string
+
+	return orgs, nil
+}
+
+func ListGitHubProjectsfromUser(username string) ([]*github.Repository, error) {
+
+	// Replace with your access token
+	token := "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"
+
+	// Create an oauth2 token source with the access token
+	tokenSource := oauth2.StaticTokenSource(
+		&oauth2.Token{AccessToken: token},
+	)
+
+	// Create an oauth2 http client with the token source
+	oauth2Client := oauth2.NewClient(context.Background(), tokenSource)
+
+	// Create a new github client with the oauth2 http client
+	client := github.NewClient(oauth2Client)
+
+	// List the repositories of the user
+	repos, _, err := client.Repositories.List(context.Background(), username, nil)
+	if err != nil {
+		fmt.Println(err)
+		return nil, err
+	}
+
+	return repos, nil
+}
diff --git a/cmdLists/gitTea.go b/cmdLists/gitTea.go
new file mode 100644
index 0000000..3978b51
--- /dev/null
+++ b/cmdLists/gitTea.go
@@ -0,0 +1,72 @@
+package cmdLists
+
+import (
+	"encoding/json"
+	"fmt"
+	"kode-starter/utils"
+
+	"github.com/joho/godotenv"
+)
+
+// The ListOrganization function retrieves a list of organizations from a specified URL and returns
+// their names and URLs.
+func ListGitTeaOrganization() ([]string, error) {
+	godotenv.Load()
+
+	body := UrlGetBody(CfgGlobal.GetUrlApiOrgs())
+	if CfgGlobal.GetJsonFlag() {
+		return utils.BytesToStrings(body), nil
+	} else {
+
+		var orgs []map[string]interface{}
+		err := json.Unmarshal(body, &orgs)
+		if err != nil {
+			return nil, err
+		} else {
+			var orgNames []string
+			for i, org := range orgs {
+				// nb := "[ " + strconv.FormatInt(int64(i+1), 10) + " ]  "
+				nb := fmt.Sprintf("[ %02d ] ", int64(i+1))
+				orgName := fmt.Sprintf("%s", org["username"])
+				orgUrl := fmt.Sprintf("[ %s/%s ]\n", CfgGlobal.GetUrlBase(), org["username"])
+				orgNames = append(
+					orgNames,
+					utils.PadString(nb, 4),
+					utils.PadDotString(orgName, 30),
+					orgUrl)
+			}
+			return orgNames, nil
+		}
+	}
+}
+
+// This function lists the projects of a given organization and returns their names and clone URLs.
+func ListGitTeaProjects(org string) ([]string, error) {
+	godotenv.Load()
+
+	body := UrlGetBody(CfgGlobal.GetUrlApiOrgs() + "/" + org + "/repos")
+	if CfgGlobal.GetJsonFlag() {
+		return utils.BytesToStrings(body), nil
+	} else {
+		var prjs []map[string]interface{}
+		err := json.Unmarshal(body, &prjs)
+		if err != nil {
+			return nil, err
+		} else {
+			var orgNames []string
+
+			for i, prj := range prjs {
+				nb := fmt.Sprintf("[ %02d ] ", int64(i+1))
+				projectName := fmt.Sprintf("%s", prj["name"])
+				cloneUrl := fmt.Sprintf("[ %s ]\n", prj["clone_url"])
+				orgNames = append(
+					orgNames,
+					utils.PadString(nb, 4),
+					utils.PadString(projectName, 40),
+					cloneUrl,
+				)
+			}
+			return orgNames, nil
+		}
+	}
+}
diff --git a/cmdLists/lists.go b/cmdLists/lists.go
index abfb860..c33e7ea 100644
--- a/cmdLists/lists.go
+++ b/cmdLists/lists.go
@@ -1,18 +1,23 @@
 package cmdLists
 
 import (
-	"encoding/json"
 	"fmt"
 	"io"
 	"kode-starter/config"
 	"kode-starter/utils"
 	"net/http"
-	"strconv"
 
-	"github.com/joho/godotenv"
 	"github.com/spf13/cobra"
 )
 
+// initailize global config
+var CfgGlobal *config.Config // Declare a global variable for config
+
+// init configuration for this package
+func InitConfig(config *config.Config) {
+	CfgGlobal = config // Assign the passed config to the global variable
+}
+
 // This is a variable declaration that creates a new Cobra command called `ListCmd`. The command has a
 // `Use` field that specifies the name of the command, a `Short` field that provides a brief
 // description of the command, and a `Long` field that provides a more detailed description of the
@@ -25,112 +30,84 @@ var ListCmd = &cobra.Command{
 	Long:  `A simple CLI app to list Github, Gitea orgs, project`,
 	Run: func(cmd *cobra.Command, args []string) {
 
-		config.SetInformations(cmd, args)
+		// Start list command
+		startList(cmd, args)
+
+	},
+}
+
+// The startList function sets some configuration information based on the command line arguments.
+func startList(cmd *cobra.Command, args []string) {
+
+	CfgGlobal.DebugPrintConfig("Function startList")
+
+	// initialize global config for command list
+	CfgGlobal.InitCmdList(cmd, args)
+
+	// print header if json flag is not set
+	if !CfgGlobal.GetJsonFlag() {
+		utils.PrintHeader()
+	}
+
+	if CfgGlobal.GetTeaFlag() {
 
 		// if -o flag is set, list projects for that org
-		if config.GetListOrganisationFlag() {
-			if !config.GetJsonFlag() {
-				// utils.PrintHeader()
-				fmt.Println("\nList projects for org: " + config.GetListOrganisation() + "\n")
-				fmt.Println(utils.CreateLine(6))
+		if CfgGlobal.GetListOrganizationFlag() {
+			if !CfgGlobal.GetJsonFlag() {
+				fmt.Println("\n   L I S T   P R O J E C T S   F O R   O R G. ")
+				fmt.Println(utils.CreateLine(8))
+				fmt.Println("   ==>  " + CfgGlobal.GetListOrganization() + "  <== ")
+				fmt.Println(utils.CreateLine(8))
 			}
-			projects, err := ListProjects(config.GetListOrganisation())
+			projects, err := ListGitTeaProjects(CfgGlobal.GetListOrganization())
 			if err != nil {
 				fmt.Println("Error:", err)
 				return
 			}
 			for _, project := range projects {
-				fmt.Print(project)
+				fmt.Println(project)
+				// fmt.Print(project)
 			}
+			fmt.Println(utils.CreateLine(8))
+
 		} else {
-			orgs, err := ListOrganization()
+			orgs, err := ListGitTeaOrganization()
 			if err != nil {
 				fmt.Println("Error:", err)
 				return
 			}
-			if !config.GetJsonFlag() {
-				fmt.Println("\nList of Organizations :")
-				fmt.Println(utils.CreateLine(4))
+			if !CfgGlobal.GetJsonFlag() {
+				fmt.Println("\n   L I S T   O R G A N I Z A T I O N S")
+				fmt.Println(utils.CreateLine(8))
 			}
 			for _, org := range orgs {
+
 				fmt.Print(org)
 			}
+			fmt.Println(utils.CreateLine(8))
 		}
+	} else if CfgGlobal.GetGitFlag() {
+		fmt.Println("\n   L I S T   G I T H U B   P R O J E C T S   F O R  : " + CfgGlobal.GetListUser())
+		fmt.Println(utils.CreateLine(11))
+		repos, err := ListGitHubProjectsfromUser(CfgGlobal.GetListUser())
+		if err != nil {
+			fmt.Println("Error:", err)
+			return
+		}
+		nb := 1
+		for _, repo := range repos {
+			utils.PrintTreeElement(nb, *repo.Name, *repo.HTMLURL)
+			nb++
+		}
+		fmt.Println(utils.CreateLine(11))
 
-	},
-}
-
-// The ListOrganization function retrieves a list of organizations from a specified URL and returns
-// their names and URLs.
-func ListOrganization() ([]string, error) {
-	godotenv.Load()
-
-	if config.GetVerboseFlag() {
-		fmt.Println("execute ListOrganization ...")
-		fmt.Println("URL: " + config.GetUrlApiOrgs())
-		fmt.Println("Token: " + config.GetToken())
-	}
-	body := UrlGetBody(config.GetUrlApiOrgs())
-	if config.GetJsonFlag() {
-		return utils.BytesToStrings(body), nil
 	} else {
 
-		var orgs []map[string]interface{}
-		err := json.Unmarshal(body, &orgs)
-		if err != nil {
-			return nil, err
-		} else {
-			var orgNames []string
-			for i, org := range orgs {
-				nb := strconv.FormatInt(int64(i+1), 10)
-				orgName := fmt.Sprintf("%s", org["username"])
-				orgUrl := fmt.Sprintf("[  %s/%s  ]\n", config.GetUrlBase(), org["username"])
-				orgNames = append(
-					orgNames,
-					utils.PadString(nb, 4),
-					utils.PadString(orgName, 30),
-					orgUrl)
-			}
-			return orgNames, nil
-		}
-	}
-}
+		// print help if no flag is set
+		cmd.Help()
 
-// This function lists the projects of a given organization and returns their names and clone URLs.
-func ListProjects(org string) ([]string, error) {
-	godotenv.Load()
-
-	if config.GetVerboseFlag() {
-		fmt.Println("execute ListProjects ...")
-		fmt.Println("URL: " + config.GetUrlApiOrgs())
-		fmt.Println("Token: " + config.GetToken())
 	}
 
-	body := UrlGetBody(config.GetUrlApiOrgs() + "/" + org + "/repos")
-	if config.GetJsonFlag() {
-		return utils.BytesToStrings(body), nil
-	} else {
-		var prjs []map[string]interface{}
-		err := json.Unmarshal(body, &prjs)
-		if err != nil {
-			return nil, err
-		} else {
-			var orgNames []string
-
-			for i, prj := range prjs {
-				nb := strconv.FormatInt(int64(i+1), 10)
-				projectName := fmt.Sprintf("%s", prj["name"])
-				cloneUrl := fmt.Sprintf("[  %s  ]\n", prj["clone_url"])
-				orgNames = append(
-					orgNames,
-					utils.PadString(nb, 4),
-					utils.PadString(projectName, 40),
-					cloneUrl,
-				)
-			}
-			return orgNames, nil
-		}
-	}
 }
 
 // This function sends a GET request to a specified URL with authorization and content-type headers,
@@ -142,7 +119,7 @@ func UrlGetBody(url string) []byte {
 		fmt.Println("Error creating request:", err)
 
 	}
-	req.Header.Set("Authorization", "token "+config.GetToken())
+	req.Header.Set("Authorization", "token "+CfgGlobal.GetTokenEnv())
 	req.Header.Set("Content-Type", "application/json")
 	// fmt.Println(req.Header.Get("Authorization"))
 	resp, err := http.DefaultClient.Do(req)
diff --git a/config/config.go b/config/config.go
index 7c32108..ac384d6 100644
--- a/config/config.go
+++ b/config/config.go
@@ -3,376 +3,701 @@ package config
 import (
 	"fmt"
 	"kode-starter/utils"
+	"time"
 
 	"github.com/spf13/cobra"
 )
 
 type Config struct {
-	DebugMode bool
-	LogLevel  string
+	DebugMode         bool
+	LogLevel          string
+	author            string
+	ModifDate         string
+	ConfigFileYmlName string
+	TokenEnv          string
+	VerboseFlag       bool
+	JsonFlag          bool
+	VersionFlag       bool
+	HelpFlag          bool
+	Url               URLConfig
+	ListCmd           ListCmdConfig
+	CreateCmd         CreateCmdConfig
+	EnvCmd            EnvCmdConfig
+	applicationName   string
 }
 
-var author string = "Bruno Charest"
-
-var modifDate string = "2023-06-12"
-
-var ConfigFileYmlName string = "config.yml"
-
-var tokenEnv string = utils.GetGitToken()
-
-var verboseFlag bool = false
-
-var jsonFlag bool = false
-
-var versionFlag bool = false
-
-var helpFlag bool = false
-
-// variables for URL
-// -----------------
-var urlBase string = "https://git.bcmaison.cf"
-
-var urlApiBase string = urlBase + "/api/v1"
-
-var urlApiOrgs string = urlApiBase + "/orgs"
-
-// variables for list command
-// --------------------------
-var listOrganization string
-
-var listOrganizationFlag bool = false
-
-// variables for create command
-// ----------------------------
-var createName string
-
-var createOrganisation string
-
-var createDescription string
-
-var createPrivatge string
-
-// variables for env command
-// -------------------------
-var EnvVariablesFlag bool = false
-
-var envVariablesFilterFlag bool = false
-
-var ennVariablesListFlag bool = false
-
-var envVariablesFilter string
-
-var envVariablesYmlFlag bool = false
-
-var envVariablesCategoryFlag bool = false
-
-var envVariablesCategory string
-
-var envVariablesSetFlag bool = false
-
-// general functions
-// -----------------
-func GetAuthor() string {
-	return author
+type URLConfig struct {
+	Base    string
+	ApiBase string
+	ApiOrgs string
 }
 
-func GetBuildDate() string {
-	return modifDate
+type ListCmdConfig struct {
+	Organization         string
+	GitFlag              bool
+	TeaFlag              bool
+	User                 string
+	listOrganizationFlag bool
 }
 
-func GetConfigFileName() string {
-	return ConfigFileYmlName
+type CreateCmdConfig struct {
+	Name         string
+	Organisation string
+	Description  string
+	Private      bool
 }
 
-func GetToken() string {
-	return tokenEnv
+type EnvCmdConfig struct {
+	EnvVariablesFlag         bool
+	EnvVariablesListFlag     bool
+	EnvVariablesFilterFlag   bool
+	EnvVariablesFilter       string
+	EnvVariablesYmlFlag      bool
+	EnvVariablesCategoryFlag bool
+	EnvVariablesCategory     string
+	EnvVariablesSetFlag      bool
+	EnvVariablesShowAllFlag  bool
 }
 
-func SetToken(token string) {
-	tokenEnv = token
+// * * * * * * * * * * * * * * * * * * * * * * * * //
+// **** G E N E R A L  GETTER - SETTER ****
+// * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Getter for DebugMode field
+func (c *Config) GetDebugMode() bool {
+	return c.DebugMode
 }
 
-func GetJsonFlag() bool {
-	return jsonFlag
+// Setter for DebugMode field
+func (c *Config) SetDebugMode(value bool) {
+	c.DebugMode = value
 }
 
-func SetJsonFlag(flag bool) {
-	jsonFlag = flag
+// Getter for LogLevel field
+func (c *Config) GetLogLevel() string {
+	return c.LogLevel
 }
 
-func GetUrlBase() string {
-	return urlBase
+// Setter for LogLevel field
+func (c *Config) SetLogLevel(value string) {
+	c.LogLevel = value
 }
 
-func GetUrlApiBase() string {
-	return urlApiBase
+// Getter for author field
+func (c *Config) GetAuthor() string {
+	return c.author
 }
 
-func GetUrlApiOrgs() string {
-	return urlApiOrgs
+// Setter for author field
+func (c *Config) SetAuthor(value string) {
+	c.author = value
 }
 
-func GetVerboseFlag() bool {
-	return verboseFlag
+// Getter for modifDate field
+func (c *Config) GetModifDate() string {
+	return c.ModifDate
 }
 
-func SetVerboseFlag(flag bool) {
-	verboseFlag = flag
+// Setter for modifDate field
+func (c *Config) SetModifDate(value string) {
+	c.ModifDate = value
 }
 
-func SetVersionFlag(flag bool) {
-	versionFlag = flag
+// Getter for ConfigFileYmlName field
+func (c *Config) GetConfigFileYmlName() string {
+	return c.ConfigFileYmlName
 }
 
-func GetVersionFlag() bool {
-	return versionFlag
+// Setter for ConfigFileYmlName field
+func (c *Config) SetConfigFileYmlName(value string) {
+	c.ConfigFileYmlName = value
 }
 
-func SetHelpFlag(flag bool) {
-	helpFlag = flag
+// Getter for tokenEnv field
+func (c *Config) GetTokenEnv() string {
+	return c.TokenEnv
 }
 
-func GetHelpFlag() bool {
-	return helpFlag
+// Setter for tokenEnv field
+func (c *Config) SetTokenEnv(value string) {
+	c.TokenEnv = value
 }
 
-// functions for list command
-// --------------------------
-func SetListOrganisation(name string) {
-	listOrganization = name
+// Getter for verboseFlag field
+func (c *Config) GetVerboseFlag() bool {
+	return c.VerboseFlag
 }
 
-func GetListOrganisation() string {
-	return listOrganization
+// Setter for verboseFlag field
+func (c *Config) SetVerboseFlag(value bool) {
+	c.VerboseFlag = value
 }
 
-func SetListOrganisationFlag(flag bool) {
-	listOrganizationFlag = flag
+// Getter for jsonFlag field
+func (c *Config) GetJsonFlag() bool {
+	return c.JsonFlag
 }
 
-func GetListOrganisationFlag() bool {
-	return listOrganizationFlag
+// Setter for jsonFlag field
+func (c *Config) SetJsonFlag(value bool) {
+	c.JsonFlag = value
 }
 
-// functions for create command
-// ----------------------------
-func GetCreateName() string {
-	return createName
+// Getter for versionFlag field
+func (c *Config) GetVersionFlag() bool {
+	return c.VersionFlag
 }
 
-func SetCreateName(name string) {
-	createName = name
+// Setter for versionFlag field
+func (c *Config) SetVersionFlag(value bool) {
+	c.VersionFlag = value
 }
 
-func GetCreateOrganisation() string {
-	return createOrganisation
+// Getter for helpFlag field
+func (c *Config) GetHelpFlag() bool {
+	return c.HelpFlag
 }
 
-func SetCeateOrganisation(organisation string) {
-	createOrganisation = organisation
+// Setter for helpFlag field
+func (c *Config) SetHelpFlag(value bool) {
+	c.HelpFlag = value
 }
 
-func GetCreateDescription() string {
-	return createDescription
+// Getter for url field
+func (c *Config) GetUrl() URLConfig {
+	return c.Url
 }
 
-func SetCeateDescription(description string) {
-	createDescription = description
+// Setter for url field
+func (c *Config) SetUrl(value URLConfig) {
+	c.Url = value
 }
 
-func GetCreatePrivate() string {
-	return createPrivatge
+// Getter urlBase field
+func (c *Config) GetUrlBase() string {
+	return c.Url.Base
 }
 
-func SetCreatePrivate(private string) {
-	createPrivatge = private
+// Setter urlBase field
+func (c *Config) SetUrlBase(value string) {
+	c.Url.Base = value
 }
 
-// function for env command
-// ------------------------
-func GetEnvVariablesFlag() bool {
-	return EnvVariablesFlag
+// Getter urlApiBase field
+func (c *Config) GetUrlApiBase() string {
+	return c.Url.ApiBase
 }
 
-func SetEnvVariablesFlag(flag bool) {
-	EnvVariablesFlag = flag
+// Setter urlApiBase field
+func (c *Config) SetUrlApiBase(value string) {
+	c.Url.ApiBase = value
 }
 
-func GetEnvVariablesFilterFlag() bool {
-	return envVariablesFilterFlag
+// Getter urlApiOrgs field
+func (c *Config) GetUrlApiOrgs() string {
+	return c.Url.ApiOrgs
 }
 
-func SetEnvVariablesFilterFlag(flag bool) {
-	envVariablesFilterFlag = flag
+// Setter urlApiOrgs field
+func (c *Config) SetUrlApiOrgs(value string) {
+	c.Url.ApiOrgs = value
 }
 
-func GetEnvVariablesFilter() string {
-	return envVariablesFilter
+// Getter for applicationName field
+func (c *Config) GetApplicationName() string {
+	return c.applicationName
 }
 
-func SetEnvVariablesFilter(filter string) {
-	envVariablesFilter = filter
+// Setter for applicationName field
+func (c *Config) SetApplicationName(value string) {
+	c.applicationName = value
 }
 
-func GetEnvVariablesListFlag() bool {
-	return ennVariablesListFlag
+// * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * L I S T C M D   GETTER - SETTER  * * * *
+// * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Getter for listCmd field
+func (c *Config) GetListCmd() ListCmdConfig {
+	return c.ListCmd
 }
 
-func SetEnvVariablesListFlag(flag bool) {
-	ennVariablesListFlag = flag
+// Setter for listCmd field
+func (c *Config) SetListCmd(value ListCmdConfig) {
+	c.ListCmd = value
 }
 
-func GetEnvVariablesYmlFlag() bool {
-	return envVariablesYmlFlag
+// Getter for listOrganizationFlag field
+func (c *Config) GetListOrganizationFlag() bool {
+	return c.ListCmd.listOrganizationFlag
 }
 
-func SetEnvVariablesYmlFlag(flag bool) {
-	envVariablesYmlFlag = flag
+// Setter for listOrganizationFlag field
+func (c *Config) SetListOrganizationFlag(value bool) {
+	c.ListCmd.listOrganizationFlag = value
 }
 
-func GetEnvVariablesCategoryFlag() bool {
-	return envVariablesCategoryFlag
+// Getter for listOrganization field
+func (c *Config) GetListOrganization() string {
+	return c.ListCmd.Organization
 }
 
-func SetEnvVariablesCategoryFlag(flag bool) {
-	envVariablesCategoryFlag = flag
+// Setter for listOrganization field
+func (c *Config) SetListOrganization(value string) {
+	c.ListCmd.Organization = value
 }
 
-func GetEnvVariablesCategory() string {
-	return envVariablesCategory
+// getter for Git flag
+func (c *Config) GetGitFlag() bool {
+	return c.ListCmd.GitFlag
 }
 
-func SetEnvVariablesCategory(category string) {
-	envVariablesCategory = category
+// setter for Git flag
+func (c *Config) SetGitFlag(value bool) {
+	c.ListCmd.GitFlag = value
 }
 
-func GetEnvVariablesSetFlag() bool {
-	return envVariablesSetFlag
+// getter for Tea flag
+func (c *Config) GetTeaFlag() bool {
+	return c.ListCmd.TeaFlag
 }
 
-func SetEnvVariablesSetFlag(flag bool) {
-	envVariablesSetFlag = flag
+// setter for Tea flag
+func (c *Config) SetTeaFlag(value bool) {
+	c.ListCmd.TeaFlag = value
 }
 
-// SetInformations - set informations from command line
-func SetInformations(cmd *cobra.Command, args []string) {
+// getter for User
+func (c *Config) GetListUser() string {
+	return c.ListCmd.User
+}
+
+// setter for User
+func (c *Config) SetListUser(value string) {
+	c.ListCmd.User = value
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * C R E A T E C M D   GETTER - SETTER  * * * *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Getter for createCmd field
+func (c *Config) GetCreateCmd() CreateCmdConfig {
+	return c.CreateCmd
+}
+
+// Setter for createCmd field
+func (c *Config) SetCreateCmd(value CreateCmdConfig) {
+	c.CreateCmd = value
+}
+
+// Getter for createName field
+func (c *Config) GetCreateName() string {
+	return c.CreateCmd.Name
+}
+
+// Setter for createName field
+func (c *Config) SetCreateName(value string) {
+	c.CreateCmd.Name = value
+}
+
+// Getter for createDescription field
+func (c *Config) GetCreateDescription() string {
+	return c.CreateCmd.Description
+}
+
+// Setter for createDescription field
+func (c *Config) SetCreateDescription(value string) {
+	c.CreateCmd.Description = value
+}
+
+// Getter for createPrivate field
+func (c *Config) GetCreatePrivate() bool {
+	return c.CreateCmd.Private
+}
+
+// Setter for createPrivate field
+func (c *Config) SetCreatePrivate(value bool) {
+	c.CreateCmd.Private = value
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * E N V C M D   GETTER - SETTER  * * * *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Getter for envCmd field
+func (c *Config) GetEnvCmd() EnvCmdConfig {
+	return c.EnvCmd
+}
+
+// Setter for envCmd field
+func (c *Config) SetEnvCmd(value EnvCmdConfig) {
+	c.EnvCmd = value
+}
+
+// Getter for envVariblesFlag flag
+func (c *Config) GetEnvVariblesFlag() bool {
+	return c.EnvCmd.EnvVariablesFlag
+}
+
+// Setter for envVariblesFlag flag
+func (c *Config) SetEnvVariblesFlag(value bool) {
+	c.EnvCmd.EnvVariablesFlag = value
+}
+
+// Getter for env list  flag
+func (c *Config) GetEnvListFlag() bool {
+	return c.EnvCmd.EnvVariablesListFlag
+}
+
+// Setter for env list flag
+func (c *Config) SetEnvListFlag(value bool) {
+	c.EnvCmd.EnvVariablesListFlag = value
+}
+
+// Getter for env filter flag
+func (c *Config) GetEnvFilterFlag() bool {
+	return c.EnvCmd.EnvVariablesFilterFlag
+}
+
+// Setter for env filter flag
+func (c *Config) SetEnvFilterFlag(value bool) {
+	c.EnvCmd.EnvVariablesFilterFlag = value
+}
+
+// Getter for env filter
+func (c *Config) GetEnvFilter() string {
+	return c.EnvCmd.EnvVariablesFilter
+}
+
+// Setter for env filter
+func (c *Config) SetEnvFilterInfo(value string) {
+	c.EnvCmd.EnvVariablesFilter = value
+}
+
+// Getter for env yml file flag
+func (c *Config) GetEnvYmlFileFlag() bool {
+	return c.EnvCmd.EnvVariablesYmlFlag
+}
+
+// Setter for env yml file flag
+func (c *Config) SetEnvYmlFileFlag(value bool) {
+	c.EnvCmd.EnvVariablesYmlFlag = value
+}
+
+// Getter for env category flag
+func (c *Config) GetEnvCategoryFlag() bool {
+	return c.EnvCmd.EnvVariablesCategoryFlag
+}
+
+// Setter for env category flag
+func (c *Config) SetEnvCategoryFlag(value bool) {
+	c.EnvCmd.EnvVariablesCategoryFlag = value
+}
+
+// Getter for env category Info
+func (c *Config) GetEnvCategoryInfo() string {
+	return c.EnvCmd.EnvVariablesCategory
+}
+
+// Setter for env category Info
+func (c *Config) SetEnvCategoryInfo(value string) {
+	c.EnvCmd.EnvVariablesCategory = value
+}
+
+// Getter for env Set flag
+func (c *Config) GetEnvSetFlag() bool {
+	return c.EnvCmd.EnvVariablesSetFlag
+}
+
+// Setter for env Set flag
+func (c *Config) SetEnvSetFlag(value bool) {
+	c.EnvCmd.EnvVariablesSetFlag = value
+}
+
+// Getter for env Show All flag
+func (c *Config) GetEnvShowAllFlag() bool {
+	return c.EnvCmd.EnvVariablesShowAllFlag
+}
+
+// Setter for env Show All flag
+func (c *Config) SetEnvShowAllFlag(value bool) {
+	c.EnvCmd.EnvVariablesShowAllFlag = value
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// initialize basic configuration
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+func (c *Config) Init() {
+
+	// autor
+	var author string = "Bruno Charest"
+	// Cfg.SetAuthor(author)
+	c.SetAuthor(author)
+
+	// set modification date to current date
+	var modifDate string = time.Now().Format("2006-01-02")
+	c.SetModifDate(modifDate)
+
+	// set config file name
+	var configFileYmlName string = "config.yml"
+	c.SetConfigFileYmlName(configFileYmlName)
+
+	// set token from environment variable
+	var tokenEnv string = utils.GetGitTokenFromOsEnv()
+	c.SetTokenEnv(tokenEnv)
+
+	// set verbose flag
+	c.SetVerboseFlag(false)
+
+	// set json flag
+	c.SetJsonFlag(false)
+
+	// set version flag
+	c.SetVersionFlag(false)
+
+	// set help flag
+	c.SetHelpFlag(false)
+
+	// set url base
+	var urlBase string = "https://git.bcmaison.cf"
+	c.SetUrlBase(urlBase)
+
+	// set url api base
+	var urlApiBase string = urlBase + "/api/v1"
+	c.SetUrlApiBase(urlApiBase)
+
+	// set url api orgs
+	var urlApiOrgs string = urlApiBase + "/orgs"
+	c.SetUrlApiOrgs(urlApiOrgs)
+
+	//set application name
+	var appName string = "Kode-Creator"
+	c.SetApplicationName(appName)
+
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// initialize configuration for commands and flags
+// for root command
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+func (c *Config) InitCmdRoot(cmd *cobra.Command, args []string) {
 
 	// Check if the version flag is set
 	if cmd.Flags().Changed("version") || cmd.Flags().Changed("V") {
-		SetVersionFlag(true)
+		c.SetVersionFlag(true)
 	}
 
 	// Check if the verbose flag is set
 	if cmd.Flags().Changed("verbose") || cmd.Flags().Changed("v") {
-		SetVerboseFlag(true)
+		c.SetVerboseFlag(true)
 	} else {
-		SetVerboseFlag(false)
+		c.SetVerboseFlag(false)
 	}
 
 	// Check if the json flag is set
 	if cmd.Flags().Changed("json") || cmd.Flags().Changed("j") {
-		SetJsonFlag(true)
+		c.SetJsonFlag(true)
 	} else {
-		SetJsonFlag(false)
+		c.SetJsonFlag(false)
 	}
 
 	// check if the help flag is set
 	if cmd.Flags().Changed("help") || cmd.Flags().Changed("h") {
-		SetHelpFlag(true)
+		c.SetHelpFlag(true)
 	}
 
-	if cmd.Flags().Changed("name") || cmd.Flags().Changed("n") {
-		SetCreateName(cmd.Flag("name").Value.String())
-	}
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// initialize configuration command and flags
+// for list command
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+func (c *Config) InitCmdList(cmd *cobra.Command, args []string) {
 
 	if cmd.Flags().Changed("org") || cmd.Flags().Changed("o") {
 		if cmd.Name() == "list" {
-			SetListOrganisation(cmd.Flag("org").Value.String())
-			SetListOrganisationFlag(true)
+			c.SetListOrganization(cmd.Flag("org").Value.String())
+			c.SetListOrganizationFlag(true)
 		} else {
-			SetCeateOrganisation(cmd.Flag("org").Value.String())
+			c.SetListOrganization(cmd.Flag("org").Value.String())
+		}
+	}
+
+	if cmd.Flags().Changed("user") || cmd.Flags().Changed("u") {
+		c.SetListUser(cmd.Flag("user").Value.String())
+	}
+
+	if cmd.Flags().Changed("git") || cmd.Flags().Changed("g") {
+		c.SetGitFlag(true)
+	}
+
+	if cmd.Flags().Changed("tea") || cmd.Flags().Changed("a") {
+		c.SetTeaFlag(true)
+	}
+
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// initialize configuration for commands and flags
+// for create command
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+func (c *Config) InitCmdCreate(cmd *cobra.Command, args []string) {
+
+	// initialize configuration for root command
+	// c.InitCmdRoot(cmd, args)
+
+	// validate flag on create command
+	if cmd.Name() == "create" {
+
+		// set organization flag if set
+		if cmd.Flags().Changed("org") || cmd.Flags().Changed("o") {
+			c.SetListOrganization(cmd.Flag("org").Value.String())
+			c.SetListOrganizationFlag(true)
 		}
 
-	}
+		// set name flag if set
+		if cmd.Flags().Changed("name") || cmd.Flags().Changed("n") {
+			c.SetCreateName(cmd.Flag("name").Value.String())
+		}
 
-	if cmd.Flags().Changed("desc") || cmd.Flags().Changed("d") {
-		SetCeateDescription(cmd.Flag("desc").Value.String())
-	}
+		// set description flag if set
+		if cmd.Flags().Changed("desc") || cmd.Flags().Changed("d") {
+			c.SetCreateDescription(cmd.Flag("desc").Value.String())
+		}
 
-	if cmd.Flags().Changed("private") || cmd.Flags().Changed("p") {
-		SetCreatePrivate(cmd.Flag("private").Value.String())
-	}
-
-	// set env variables flag if set
-	if cmd.Flags().Changed("env") || cmd.Flags().Changed("e") {
-		SetEnvVariablesFlag(true)
-
-		// if flag list is set, set filter flag
-		if cmd.Flags().Changed("list") || cmd.Flags().Changed("l") {
-			SetEnvVariablesListFlag(true)
-
-			// set env variables filter flag if set
-			if cmd.Flags().Changed("filter") || cmd.Flags().Changed("f") {
-				SetEnvVariablesFilter(cmd.Flag("filter").Value.String())
+		// set private flag if set
+		if cmd.Flags().Changed("private") || cmd.Flags().Changed("p") {
+			if cmd.Flag("private").Value.String() == "true" {
+				c.SetCreatePrivate(true)
+			} else if cmd.Flag("private").Value.String() == "false" {
+				c.SetCreatePrivate(false)
+			} else {
+				c.SetCreatePrivate(false)
 			}
-
-		} else if cmd.Flags().Changed("yml") || cmd.Flags().Changed("y") {
-			SetEnvVariablesYmlFlag(true)
-
-			// set env variables category flag if set
-			if cmd.Flags().Changed("category") || cmd.Flags().Changed("c") {
-				SetEnvVariablesCategoryFlag(true)
-				SetEnvVariablesCategory(cmd.Flag("category").Value.String())
-			}
-
-		} else if cmd.Flags().Changed("set") || cmd.Flags().Changed("s") {
-			SetEnvVariablesSetFlag(true)
-		}
-
-	}
-
-	// If verbose flag is set, print informations
-	if GetVerboseFlag() {
-		if cmd.Name() == "list" {
-			fmt.Println("SetInformations - progress list option:")
-			fmt.Println("SetInformations - org:" + cmd.Flag("org").Value.String())
-			fmt.Println("SetInformations - cmd Usertoken:" + cmd.Flag("token").Value.String())
-		}
-		if cmd.Name() == "create" {
-			fmt.Println("SetInformations - progress create option:")
-			fmt.Println("SetInformations - name:" + cmd.Flag("name").Value.String())
-			fmt.Println("SetInformations - description:" + cmd.Flag("desc").Value.String())
-			fmt.Println("SetInformations - private:" + cmd.Flag("private").Value.String())
-			fmt.Println("SetInformations - cmd Usertoken:" + cmd.Flag("token").Value.String())
-			fmt.Println("SetInformations - org:" + cmd.Flag("org").Value.String())
-		}
-		if cmd.Name() == "env" {
-			fmt.Println("SetInformations - progress env option:")
-			// fmt.Println("SetInformations - cmd Usertoken:" + cmd.Flag("token").Value.String())
-			fmt.Println("SetInformations - env:" + cmd.Flag("env").Value.String())
-			fmt.Println("SetInformations - filter:" + cmd.Flag("filter").Value.String())
-			fmt.Println("SetInformations - list:" + cmd.Flag("list").Value.String())
-			fmt.Println("SetInformations - yml:" + cmd.Flag("yml").Value.String())
-			if GetEnvVariablesListFlag() {
-				fmt.Println("SetInformations - category:" + cmd.Flag("category").Value.String())
-			}
-			fmt.Println("SetInformations - set:" + cmd.Flag("set").Value.String())
-		}
-	}
-
-	// Check if token come from flag or env
-	if cmd.Flags().Changed("token") || cmd.Flags().Changed("t") {
-		if utils.IsValidToken(cmd.Flag("token").Value.String()) {
-			SetToken(cmd.Flag("token").Value.String())
-		} else {
-			utils.ExitWithError(10, "Invalid token, format must be 40 characters UUID.")
-		}
-
-	} else {
-		if utils.IsValidToken(utils.GetGitToken()) {
-			SetToken(utils.GetGitToken())
-		} else {
-			utils.ExitWithError(10, "Invalid token, format must be 40 characters UUID.")
 		}
 	}
 }
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// initialize configuration commands and flags
+// for env command
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+func (c *Config) InitCmdEnv(cmd *cobra.Command, args []string) {
+
+	// initialize configuration for root command
+	c.InitCmdRoot(cmd, args)
+
+	// validate flag on env command
+	if cmd.Name() == "env" {
+
+		// if flag list is set, set filter flag
+		if cmd.Flags().Changed("list") || cmd.Flags().Changed("l") {
+			c.SetEnvListFlag(true)
+
+			// // set env variables filter flag if set
+			// if cmd.Flags().Changed("filter") || cmd.Flags().Changed("f") {
+			// 	c.SetEnvFilterInfo(cmd.Flag("filter").Value.String())
+			// 	c.SetEnvFilterFlag(true)
+			// }
+
+		}
+
+		// set env variables filter flag if set
+		if cmd.Flags().Changed("filter") || cmd.Flags().Changed("f") {
+			c.SetEnvFilterInfo(cmd.Flag("filter").Value.String())
+			c.SetEnvFilterFlag(true)
+		}
+
+		if cmd.Flags().Changed("yml") || cmd.Flags().Changed("y") {
+			c.SetEnvYmlFileFlag(true)
+
+		}
+
+		if cmd.Flags().Changed("set") || cmd.Flags().Changed("s") {
+			c.SetEnvSetFlag(true)
+		}
+
+		// set env variables category flag if set
+		if cmd.Flags().Changed("cat") || cmd.Flags().Changed("c") {
+			fmt.Println("cat flag set")
+			c.SetEnvCategoryFlag(true)
+			c.SetEnvCategoryInfo(cmd.Flag("cat").Value.String())
+		}
+
+		// set env variables show all flag if set
+		if cmd.Flags().Changed("all") || cmd.Flags().Changed("a") {
+			c.SetEnvShowAllFlag(true)
+		}
+
+	}
+}
+
+// function that print all configuration if DebugMode is true
+func (c *Config) DebugPrintConfig(section string) {
+
+	if c.GetDebugMode() {
+		fmt.Println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
+		fmt.Println("|   Section:  " + section)
+		fmt.Println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
+		c.printAllConfiguration()
+	}
+}
+
+// function that print string if DebugMode is true
+func (c *Config) DebugPrintString(str string) {
+
+	if c.GetDebugMode() {
+		fmt.Println(str)
+	}
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// function to print all configuration
+// for information and flags
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+func (c *Config) printAllConfiguration() {
+
+	fmt.Println("General Configuration:")
+	fmt.Println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
+	fmt.Println("Config: DebugMode: ", c.GetDebugMode())
+	fmt.Println("Config: LogLevel: ", c.GetLogLevel())
+	fmt.Println("config: Author: ", c.GetAuthor())
+	fmt.Println("config: ModifDate: ", c.GetModifDate())
+	fmt.Println("config: ConfigFileYmlName: ", c.GetConfigFileYmlName())
+	fmt.Println("config: TokenEnv: ", c.GetTokenEnv())
+	fmt.Println("config: VerboseFlag: ", c.GetVerboseFlag())
+	fmt.Println("config: JsonFlag: ", c.GetJsonFlag())
+	fmt.Println("config: VersionFlag: ", c.GetVersionFlag())
+	fmt.Println("config: HelpFlag: ", c.GetHelpFlag())
+	fmt.Println("config: UrlBase: ", c.GetUrlBase())
+	fmt.Println("config: UrlApiBase: ", c.GetUrlApiBase())
+	fmt.Println("config: UrlApiOrgs: ", c.GetUrlApiOrgs())
+
+	fmt.Println("List Commands Configuration:")
+	fmt.Println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
+	fmt.Println("config: ListOrganization: ", c.GetListOrganization())
+	fmt.Println("config: ListOrganizationFlag: ", c.GetListOrganizationFlag())
+
+	fmt.Println("Create commands Configuration:")
+	fmt.Println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
+	fmt.Println("config: CreateName: ", c.GetCreateCmd().Name)
+	fmt.Println("config: Organization: ", c.GetCreateCmd().Organisation)
+	fmt.Println("config: CreateDescription: ", c.GetCreateCmd().Description)
+	fmt.Println("config: CreatePrivate: ", c.GetCreatePrivate())
+	fmt.Println("config: CreateCmd: ", c.GetCreateCmd())
+
+	fmt.Println("Environment Variables Configuration:")
+	fmt.Println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
+	fmt.Println("config: EnvCmd: ", c.GetEnvCmd())
+	fmt.Println("config: EnvVariablesFlag: ", c.GetEnvVariblesFlag())
+	fmt.Println("config: EnvListFlag: ", c.GetEnvListFlag())
+	fmt.Println("config: EnvFilterFlag: ", c.GetEnvFilterFlag())
+	fmt.Println("config: EnvVariablesFilter: ", c.GetEnvFilter())
+	fmt.Println("config: EnvVariablesYmlFlag: ", c.GetEnvYmlFileFlag())
+	fmt.Println("config: EnvVariablesCategoryFlag: ", c.GetEnvCategoryFlag())
+	fmt.Println("config: EnvVariablesCategory: ", c.GetEnvCategoryInfo())
+	fmt.Println("config: EnvVariablesSetFlag: ", c.GetEnvSetFlag())
+	fmt.Println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
+
+}
diff --git a/configFile/config-actionyml.go b/configFile/config-actionyml.go
index 9e9b4b3..7fa7265 100644
--- a/configFile/config-actionyml.go
+++ b/configFile/config-actionyml.go
@@ -7,22 +7,21 @@ import (
 	"os"
 )
 
-func loadConfigFile() *Config {
+func LoadConfigFile(c *config.Config) *ConfigYml {
 
-	filename := config.GetConfigFileName()
-
-	cfg, err := LoadConfig(filename)
+	filename := c.GetConfigFileYmlName()
+	cfgfile, err := LoadConfig(filename)
 	if err != nil {
 		log.Fatalf("error loading config file: %v", err)
 		os.Exit(1)
 	}
-	return cfg
+	return cfgfile
 
 }
 
-func Listcategory() {
+func Listcategory(c *config.Config) {
 
-	cfg := loadConfigFile()
+	cfg := LoadConfigFile(c)
 
 	// list all categories
 	ListCategories, err := cfg.GetListCategory()
diff --git a/configFile/config-fileyml.go b/configFile/config-fileyml.go
index c1d8765..b1d64ad 100644
--- a/configFile/config-fileyml.go
+++ b/configFile/config-fileyml.go
@@ -7,11 +7,7 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
-// The above code defines a configuration struct for software projects with sections for software,
-// environment variables, directories, and pipeline configurations.
-// @property Sections - A map of SectionConfig objects, where each key is a string representing the
-// name of the section.
-type Config struct {
+type ConfigYml struct {
 	Sections map[string]SectionConfig `yaml:"category"`
 }
 
@@ -46,14 +42,27 @@ type PipelineConfig struct {
 	Build string `yaml:"build"`
 	Test  string `yaml:"test"`
 	Lint  string `yaml:"lint"`
-	// Compile string `yaml:"compile"`
-	// Package string `yaml:"package"`
+}
+
+// function GetPathsFromCategory
+func (c *ConfigYml) GetPathsFromCategory(sectionName string) ([]string, error) {
+	section, ok := c.Sections[sectionName]
+	if !ok {
+		return nil, fmt.Errorf("section '%s' not found", sectionName)
+	}
+
+	var paths []string
+	for _, EnvVar := range section.EnvironmentsVariables {
+		paths = append(paths, EnvVar)
+	}
+
+	return paths, nil
 }
 
 // The function loads a configuration file in YAML format and returns a pointer to a Config struct or
 // an error.
-func LoadConfig(filename string) (*Config, error) {
-	var config Config
+func LoadConfig(filename string) (*ConfigYml, error) {
+	var config ConfigYml
 
 	source, err := ioutil.ReadFile(filename)
 	if err != nil {
@@ -72,7 +81,7 @@ func LoadConfig(filename string) (*Config, error) {
 }
 
 // function GetListCategory return list category from config file
-func (c *Config) GetListCategory() ([]string, error) {
+func (c *ConfigYml) GetListCategory() ([]string, error) {
 	var categories []string
 	for categoryName := range c.Sections {
 		categories = append(categories, categoryName)
@@ -84,7 +93,7 @@ func (c *Config) GetListCategory() ([]string, error) {
 // This is a method defined on the `Config` struct that returns a list of software names for a given
 // section. It takes in a `sectionName` string as a parameter and returns a slice of strings and an
 // error.
-func (c *Config) GetListSoftware(sectionName string) ([]string, error) {
+func (c *ConfigYml) GetListSoftware(sectionName string) ([]string, error) {
 	section, ok := c.Sections[sectionName]
 	if !ok {
 		return nil, fmt.Errorf("section '%s' not found", sectionName)
@@ -100,7 +109,7 @@ func (c *Config) GetListSoftware(sectionName string) ([]string, error) {
 
 // This is a method defined on the `Config` struct that takes in two string parameters `sectionName`
 // and `SoftwareName`. It returns a pointer to a `SoftwareConfig` struct and an error.
-func (c *Config) GetSoftware(sectionName, SoftwareName string) (*SoftwareConfig, error) {
+func (c *ConfigYml) GetSoftware(sectionName, SoftwareName string) (*SoftwareConfig, error) {
 	section, ok := c.Sections[sectionName]
 	if !ok {
 		return nil, fmt.Errorf("section '%s' not found", sectionName)
@@ -115,7 +124,7 @@ func (c *Config) GetSoftware(sectionName, SoftwareName string) (*SoftwareConfig,
 }
 
 // get list environment variables
-func (c *Config) GetListEnvironmentVariables(sectionName string) ([]string, error) {
+func (c *ConfigYml) GetListEnvironmentVariables(sectionName string) ([]string, error) {
 	section, ok := c.Sections[sectionName]
 	if !ok {
 		return nil, fmt.Errorf("section '%s' not found", sectionName)
@@ -134,7 +143,7 @@ func (c *Config) GetListEnvironmentVariables(sectionName string) ([]string, erro
 // section in the configuration and then looks for the specified environment variable within that
 // section. If the section or variable is not found, an error is returned. If the variable is found,
 // its value is returned.
-func (c *Config) GetEnvironmentVariables(sectionName, variableName string) (string, error) {
+func (c *ConfigYml) GetEnvironmentVariables(sectionName, variableName string) (string, error) {
 	section, ok := c.Sections[sectionName]
 	if !ok {
 		return "", fmt.Errorf("section '%s' not found", sectionName)
@@ -148,12 +157,22 @@ func (c *Config) GetEnvironmentVariables(sectionName, variableName string) (stri
 	return variable, nil
 }
 
+// get all environment variables names and values
+func (c *ConfigYml) GetAllEnvironmentVariables(sectionName string) (map[string]string, error) {
+	section, ok := c.Sections[sectionName]
+	if !ok {
+		return nil, fmt.Errorf("section '%s' not found", sectionName)
+	}
+
+	return section.EnvironmentsVariables, nil
+}
+
 // This is a method defined on the `Config` struct that takes in two string parameters `sectionName`
 // and `directoryName`. It returns a pointer to a `DirectoryConfig` struct and an error. The method
 // looks for the specified section in the configuration and then looks for the specified directory
 // within that section. If the section or directory is not found, an error is returned. If the
 // directory is found, its configuration is returned.
-func (c *Config) GetDirectory(sectionName, directoryName string) (*DirectoryConfig, error) {
+func (c *ConfigYml) GetDirectory(sectionName, directoryName string) (*DirectoryConfig, error) {
 	section, ok := c.Sections[sectionName]
 	if !ok {
 		return nil, fmt.Errorf("section '%s' not found", sectionName)
@@ -173,7 +192,7 @@ func (c *Config) GetDirectory(sectionName, directoryName string) (*DirectoryConf
 // for the specified section in the configuration and then looks for the specified pipeline within that
 // section. If the section or pipeline is not found, an error is returned. If the pipeline is found,
 // its configuration is returned.
-func (c *Config) GetPipeline(sectionName, pipelineName string) (*PipelineConfig, error) {
+func (c *ConfigYml) GetPipeline(sectionName, pipelineName string) (*PipelineConfig, error) {
 	section, ok := c.Sections[sectionName]
 	if !ok {
 		return nil, fmt.Errorf("section '%s' not found", sectionName)
diff --git a/go.mod b/go.mod
index c643ed0..6f8a6cb 100644
--- a/go.mod
+++ b/go.mod
@@ -9,9 +9,19 @@ require (
 )
 
 require (
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	golang.org/x/net v0.11.0 // indirect
+	google.golang.org/appengine v1.6.7 // indirect
+	google.golang.org/protobuf v1.28.0 // indirect
+)
+
+require (
+	github.com/google/go-github v17.0.0+incompatible
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 // indirect
-	golang.org/x/sys v0.6.0 // indirect
+	golang.org/x/oauth2 v0.9.0
+	golang.org/x/sys v0.9.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0
 )
diff --git a/go.sum b/go.sum
index 44a8b54..b537d37 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,15 @@
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-github v17.0.0+incompatible h1:N0LgJ1j65A7kfXrZnUDaYCs/Sf4rEjNlfyDHW9dolSY=
+github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
+github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
 github.com/gookit/color v1.5.3 h1:twfIhZs4QLCtimkP7MOxlF3A0U/5cDPseRT9M/+2SCE=
 github.com/gookit/color v1.5.3/go.mod h1:NUzwzeehUfl7GIb36pqId+UGmRfQcU/WiiyTTeNjHtE=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -15,8 +25,26 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
 github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 h1:QldyIu/L63oPpyvQmHgvgickp1Yw510KJOqX7H24mg8=
 github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.11.0 h1:Gi2tvZIJyBtO9SDr1q9h5hEQCp/4L2RQ+ar0qjx2oNU=
+golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
+golang.org/x/oauth2 v0.9.0 h1:BPpt2kU7oMRq3kCHAA1tbSEshXRw1LpG2ztgDwrzuAs=
+golang.org/x/oauth2 v0.9.0/go.mod h1:qYgFZaFiu6Wg24azG8bdV52QJXJGbZzIIsRCdVKzbLw=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
+google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
+google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
diff --git a/kode-starter.go b/kode-starter.go
index c7b8cfa..7346da6 100644
--- a/kode-starter.go
+++ b/kode-starter.go
@@ -11,50 +11,54 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// initailize global config
+var CfgGlobal = &config.Config{}
+
+// rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
 	Use:   "kode-creator.exe",
 	Short: "Simple cli app create startup project",
 	Long:  `A simple CLI app to work with Github, Gitea`,
 	Run: func(cmd *cobra.Command, args []string) {
 
-		config.SetInformations(cmd, args)
 		mainProgram(cmd, args)
 	},
 }
 
-var token, org, name, private, description, envGroup, envCategory string
-var verbose, createFlag, versionFlag bool
-var listEnvFlag, listEnvCfgFlag, setEnvFlag, envVariablesFlag, envGroupFlag bool
-
+// init function that will be executed before the main function
 func init() {
 
-	// var config = &config.Config{}
+	CfgGlobal.Init()
 
 	// root menu section
-	rootCmd.Flags().BoolP("help", "h", false, "Show help for create command")
-	rootCmd.Flags().BoolVarP(&versionFlag, "version", "V", false, "Show version")
+	rootCmd.Flags().BoolP("help", "h", false, "Show help for "+CfgGlobal.GetApplicationName())
+	rootCmd.Flags().BoolVarP(&CfgGlobal.VersionFlag, "version", "V", false, "Show VERSION of "+CfgGlobal.GetApplicationName())
 	rootCmd.CompletionOptions.DisableDefaultCmd = true
-	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "mode verbose")
-	rootCmd.PersistentFlags().BoolVarP(&createFlag, "json", "j", false, "Print output as json format")
+	rootCmd.PersistentFlags().BoolVarP(&CfgGlobal.VerboseFlag, "verbose", "v", false, "VERBOSE mode output")
+	rootCmd.PersistentFlags().BoolVarP(&CfgGlobal.JsonFlag, "json", "j", false, "JSON output format")
 
 	// List menu section
-	cmdLists.ListCmd.Flags().StringVarP(&token, "token", "t", "", "Github token")
-	cmdLists.ListCmd.Flags().StringVarP(&org, "org", "o", "", "Github organization")
+	cmdLists.ListCmd.Flags().StringVarP(&CfgGlobal.TokenEnv, "token", "t", "", "TOKEN for Gitea or Github")
+	cmdLists.ListCmd.Flags().BoolVarP(&CfgGlobal.ListCmd.GitFlag, "git", "g", false, "List all repositories from GITHUB")
+	cmdLists.ListCmd.Flags().BoolVarP(&CfgGlobal.ListCmd.TeaFlag, "tea", "a", false, "List all repositories from GITEA")
+	cmdLists.ListCmd.Flags().StringVarP(&CfgGlobal.ListCmd.User, "user", "u", "", "user for request on GITHUB or GITEA")
+	cmdLists.ListCmd.Flags().StringVarP(&CfgGlobal.ListCmd.Organization, "org", "o", "", "List projects from an ORGANIZATION")
 
 	// Create menu section
-	cmdCreate.CreateCmd.Flags().StringVarP(&token, "token", "t", "", "Github token")
-	cmdCreate.CreateCmd.Flags().StringVarP(&org, "org", "o", "", "Github organization")
-	cmdCreate.CreateCmd.Flags().StringVarP(&name, "name", "n", "", "Project name")
-	cmdCreate.CreateCmd.Flags().StringVarP(&description, "desc", "d", "", "Description")
-	cmdCreate.CreateCmd.Flags().StringVarP(&private, "private", "p", "", "true/false")
+	cmdCreate.CreateCmd.Flags().StringVarP(&CfgGlobal.TokenEnv, "token", "t", "", "TOKEN for Gitea or Github")
+	cmdCreate.CreateCmd.Flags().StringVarP(&CfgGlobal.CreateCmd.Organisation, "org", "o", "", "ORGANIZATION for this project")
+	cmdCreate.CreateCmd.Flags().StringVarP(&CfgGlobal.CreateCmd.Name, "name", "n", "", "NAME of the Project")
+	cmdCreate.CreateCmd.Flags().StringVarP(&CfgGlobal.CreateCmd.Description, "desc", "d", "", "DESCRIPTION of the project")
+	cmdCreate.CreateCmd.Flags().BoolVarP(&CfgGlobal.CreateCmd.Private, "private", "p", false, "PRIVATE with this switch")
 
 	// Env menu section
-	cmdEnv.EnvCmd.Flags().BoolVarP(&envVariablesFlag, "env", "e", false, "environnement variables management")
-	cmdEnv.EnvCmd.Flags().BoolVarP(&listEnvFlag, "list", "l", false, "List environnement variables")
-	cmdEnv.EnvCmd.Flags().StringVarP(&envGroup, "filter", "f", "", "Highlight a specific word in environnement variables")
-	cmdEnv.EnvCmd.Flags().BoolVarP(&listEnvCfgFlag, "yml", "y", false, "List environnement variables from config.yml")
-	cmdEnv.EnvCmd.Flags().StringVarP(&envCategory, "cat", "c", "", "filter for a specific category")
-	cmdEnv.EnvCmd.Flags().BoolVarP(&setEnvFlag, "set", "s", false, "set environnement variable available from config.yml")
+	cmdEnv.EnvCmd.Flags().BoolVarP(&CfgGlobal.EnvCmd.EnvVariablesFlag, "group", "g", false, "GROUP environnement variables by categories")
+	cmdEnv.EnvCmd.Flags().BoolVarP(&CfgGlobal.EnvCmd.EnvVariablesListFlag, "list", "l", false, "LIST environnement variables")
+	cmdEnv.EnvCmd.Flags().StringVarP(&CfgGlobal.EnvCmd.EnvVariablesFilter, "filter", "f", "", "HIGHLIGHT a specific word in environnement variables")
+	cmdEnv.EnvCmd.Flags().BoolVarP(&CfgGlobal.EnvCmd.EnvVariablesYmlFlag, "yml", "y", false, "YAML List environnement variables from config.yml")
+	cmdEnv.EnvCmd.Flags().StringVarP(&CfgGlobal.EnvCmd.EnvVariablesCategory, "cat", "c", "", "FILTER for a specific category")
+	cmdEnv.EnvCmd.Flags().BoolVarP(&CfgGlobal.EnvCmd.EnvVariablesSetFlag, "set", "s", false, "Set environnement variable available from config.yml")
+	cmdEnv.EnvCmd.Flags().BoolVarP(&CfgGlobal.EnvCmd.EnvVariablesShowAllFlag, "all", "a", false, "Show all environnement variables")
 
 	// Add subcommands
 	rootCmd.AddCommand(cmdLists.ListCmd)
@@ -63,31 +67,35 @@ func init() {
 
 }
 
+// function to print help or version
 func mainProgram(cmd *cobra.Command, args []string) {
 
-	config.SetInformations(cmd, args)
-
 	// if version flag is set, print version and exit
-	if config.GetVersionFlag() {
-		utils.PrintVersion(version.GetFullVersion(), config.GetAuthor(), config.GetBuildDate())
+	if CfgGlobal.GetVersionFlag() {
+		utils.PrintVersion(version.GetFullVersion(), CfgGlobal.GetAuthor(), CfgGlobal.GetModifDate())
 		return
 
 		// if no flag is set, print help and exit
 	} else {
 
-		//configFile.Listcategory()
-		utils.PrintHelpFormated(version.GetFullVersion(), config.GetAuthor(), config.GetBuildDate(), cmd)
+		utils.PrintHelpFormated(version.GetFullVersion(), CfgGlobal.GetAuthor(), CfgGlobal.GetModifDate(), cmd)
 		return
 	}
 
 }
 
+// main function
 func main() {
 
-	// var config = &config.Config{}
+	//initialize config
+	CfgGlobal.Init()
+	cmdLists.InitConfig(CfgGlobal)
+	cmdCreate.InitConfig(CfgGlobal)
+	cmdEnv.InitConfig(CfgGlobal)
 
-	// print header
-	utils.PrintHeader()
+	// set debug mode
+	CfgGlobal.SetDebugMode(false)
+	CfgGlobal.DebugPrintConfig("Function main")
 
 	// execute root command
 	rootCmd.Execute()
diff --git a/readme.md b/readme.md
index bab31cf..22656c3 100644
--- a/readme.md
+++ b/readme.md
@@ -68,7 +68,8 @@ You can set the following environment variables:
 - `GIT_TOKEN` - Your Github personal access token. This will be used instead of passing the `-t` flag.
 
 *Temporaire*
-(Git Token for linux)[ af65e1b846d721e3465422c04997d69b0cfe7f18 ] 
+(Gitea Token for linux)[ af65e1b846d721e3465422c04997d69b0cfe7f18 ] 
+(Github Token from Github)[ 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 ]
 
 ##License
 
diff --git a/release/linux/0.0.0.25/kode-starter b/release/linux/0.0.0.25/kode-starter
new file mode 100755
index 0000000..36577db
Binary files /dev/null and b/release/linux/0.0.0.25/kode-starter differ
diff --git a/version/version-number.go b/version/version-number.go
index af01925..3b37533 100644
--- a/version/version-number.go
+++ b/version/version-number.go
@@ -15,7 +15,7 @@ type Version struct {
 
 // version variable that will be set at build time by versionManager.exe
 // *** DO NOT EDIT ***
-var versionNumber Version = Version{0, 0, 0, 25}
+var versionNumber Version = Version{0, 0, 0, 26}
 
 // GetFullVersion returns the full version number as a string
 func GetFullVersion() string {