Support Atmos Toolchain for 3rd Party Tools

.gitignore

@@ -51,4 +51,5 @@ internal/exec/output.*
 # Coverage files
 coverage.out
 coverage.html
+node_modules
 tests.test

cmd/markdown/atmos_toolchain_add.md

@@ -0,0 +1,9 @@
+- Add a tool with version
+```
+ $ atmos toolchain add <tool-name> <version>
+```
+
+- Use a custom tool versions file
+```
+ $ atmos toolchain add --file <path/to/.tool-version> <tool-name> <version>
+```

cmd/markdown/atmos_toolchain_aliases.md

@@ -0,0 +1,4 @@
+- Get the aliases configured
+```
+ $ atmos toolchain aliases
+```

cmd/markdown/atmos_toolchain_clean.md

@@ -0,0 +1,5 @@
+- Delete everything from toolchain
+
+```
+ $ atmos toolchain clean
+```

cmd/markdown/atmos_toolchain_exec.md

@@ -0,0 +1,9 @@
+- Execute a command using the default tool
+```
+$ atmos toolchain exec <tool> <args>
+```
+
+- Execute a command using a specific tool version
+```
+$ atmos toolchain <tool>@<version> <args>
+```

cmd/markdown/atmos_toolchain_info.md

@@ -0,0 +1,5 @@
+- Display tool info based on the aqua registry
+
+```
+ $ atmos toolchain info <tool>
+```

cmd/markdown/atmos_toolchain_install.md

@@ -0,0 +1,10 @@
+
+- Install all the tools added in tool-versions
+```
+ $ atmos toolchain install
+```
+
+- Install a specifc version of a tool
+```
+ $ atmos toolchain install <tool>@<verions>
+```

cmd/markdown/atmos_toolchain_list.md

@@ -0,0 +1,4 @@
+- Get the list of toolchain tools
+```
+ $ atmos toolchain list
+```

cmd/markdown/atmos_toolchain_path.md

@@ -0,0 +1,19 @@
+- Print PATH for all tools in .tool-versions (absolute paths)
+```
+ $ atmos toolchain path                   
+```
+
+- Print the relative paths in the PATH
+```
+ $ atmos toolchain path --relative 
+```
+
+- Output the PATH for Shell scripting
+```
+ $ atmos toolchain path --export
+```
+
+- Print PATH as JSON object
+```
+ $ atmos toolchain path --json
+```

cmd/markdown/atmos_toolchain_remove.md

@@ -0,0 +1,9 @@
+- Remove all versions of a tool
+```
+$ atmos toolchain remove terraform
+```
+
+- Remove a specific version of the tool
+```
+$ atmos toolchain remove <tool>@<version>
+```

cmd/markdown/atmos_toolchain_set.md

@@ -0,0 +1,9 @@
+- Set a default version for the tool
+```
+ $ atmos toolchain set <tool> 1.11.4
+```
+
+- Open the interactive UI to set tool versions
+```
+ $ atmos toolchain set hashicorp/terraform
+```

cmd/markdown/atmos_toolchain_uninstall.md

@@ -0,0 +1,9 @@
+- Uninstall a tool
+```
+ $ atmos toolchain uninstall [email protected]
+```
+
+- Uninstall all the tools from .tool-versions
+```
+ $ atmos toolchain uninstall
+```

cmd/markdown/atmos_toolchain_versions.md

@@ -0,0 +1,19 @@
+- Execute a toolchain version
+```
+ $ atmos toolchain versions <tool>
+```
+
+- Execute a toolchain versions
+```
+ $ atmos toolchain versions <tool> --file <path/to/tool-versions>
+```
+
+- Get all the versions of the tool
+```
+ $ atmos toolchain versions <tool> --all
+```
+
+- Limit the number of versions returned for a tool
+```
+ $ atmos toolchain versions <tool> --limit <number>
+```

cmd/markdown/atmos_toolchain_which.md

@@ -0,0 +1,5 @@
+- Get the path of the tool 
+
+```
+ $ atmos toolchain which <tool>
+```

cmd/root.go

@@ -26,6 +26,7 @@ import (
 	"github.com/cloudposse/atmos/pkg/schema"
 	"github.com/cloudposse/atmos/pkg/telemetry"
 	"github.com/cloudposse/atmos/pkg/utils"
+	"github.com/cloudposse/atmos/toolchain"
 )
 
 // atmosConfig This is initialized before everything in the Execute function. So we can directly use this.
@@ -139,7 +140,7 @@ func Execute() error {
 	// Here we need the custom commands from the config
 	var initErr error
 	atmosConfig, initErr = cfg.InitCliConfig(schema.ConfigAndStacksInfo{}, false)
-
+	toolchain.SetAtmosConfig(&atmosConfig)
 	utils.InitializeMarkdown(atmosConfig)
 	errUtils.InitializeMarkdown(atmosConfig)
 
@@ -209,6 +210,8 @@ func init() {
 	RootCmd.PersistentFlags().StringSlice("config", []string{}, "Paths to configuration files (comma-separated or repeated flag)")
 	RootCmd.PersistentFlags().StringSlice("config-path", []string{}, "Paths to configuration directories (comma-separated or repeated flag)")
 	RootCmd.PersistentFlags().Bool("no-color", false, "Disable color output")
+
+	RootCmd.AddCommand(ToolChainCmd)
 	// Set custom usage template
 	err := templates.SetCustomUsageFunc(RootCmd)
 	if err != nil {

cmd/toolchain.go

@@ -0,0 +1,64 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var (
+	githubToken      string
+	toolVersionsFile string
+	toolsDir         string
+	toolsConfigFile  string
+)
+
+var ToolChainCmd = &cobra.Command{
+	Use:   "toolchain",
+	Short: "Toolchain CLI",
+	Long:  `A standalone tool to install CLI binaries using registry metadata.`,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		// Set log level
+		return nil
+	},
+}
+
+func init() {
+	// Add GitHub token flag and bind to environment variables
+	ToolChainCmd.PersistentFlags().StringVar(&githubToken, "github-token", "", "GitHub token for authenticated requests")
+	ToolChainCmd.PersistentFlags().MarkHidden("github-token") // Hide from help since it's primarily for env vars
+	// Bind environment variables with proper precedence (ATMOS_GITHUB_TOKEN takes precedence over GITHUB_TOKEN)
+	if err := viper.BindPFlag("github-token", ToolChainCmd.PersistentFlags().Lookup("github-token")); err != nil {
+		fmt.Fprintf(os.Stderr, "Error binding github-token flag: %v\n", err)
+	}
+	if err := viper.BindEnv("github-token", "ATMOS_GITHUB_TOKEN", "GITHUB_TOKEN"); err != nil {
+		fmt.Fprintf(os.Stderr, "Error binding github-token environment variables: %v\n", err)
+	}
+
+	// Add tool-versions file flagd
+	ToolChainCmd.PersistentFlags().StringVar(&toolVersionsFile, "tool-versions", ".tool-versions", "Path to tool-versions file")
+
+	// Add tools directory flag
+	ToolChainCmd.PersistentFlags().StringVar(&toolsDir, "tools-dir", ".tools", "Directory to store installed tools")
+
+	// Add tools config file flag
+	ToolChainCmd.PersistentFlags().StringVar(&toolsConfigFile, "tools-config", "tools.yaml", "Path to tools configuration file")
+}
+
+func init() {
+	ToolChainCmd.AddCommand(toolchainAddCmd)
+	ToolChainCmd.AddCommand(toolchainRemoveCmd)
+	ToolChainCmd.AddCommand(toolchainSetCmd)
+	ToolChainCmd.AddCommand(toolchainVersionsCmd)
+	ToolChainCmd.AddCommand(toolchainCleanCmd)
+	ToolChainCmd.AddCommand(toolchainExecCmd)
+	ToolChainCmd.AddCommand(toolchainListCmd)
+	ToolChainCmd.AddCommand(toolchainInstallCmd)
+	ToolChainCmd.AddCommand(toolchainUninstallCmd)
+	ToolChainCmd.AddCommand(toolchainPathCmd)
+	ToolChainCmd.AddCommand(toolchainInfoCmd)
+	ToolChainCmd.AddCommand(toolchainAliasesCmd)
+	ToolChainCmd.AddCommand(toolchainWhichCmd)
+}

cmd/toolchain_add.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"github.com/cloudposse/atmos/toolchain"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var toolchainAddCmd = &cobra.Command{
+	Use:   "add <tool> <version>",
+	Short: "Add or update a tool and version in .tool-versions",
+	Long: `Add or update a tool and version in the .tool-versions file.
+
+This command adds a tool and its version to the .tool-versions file. If the tool
+already exists, it will be updated with the new version.
+
+The tool will be validated against the registry to ensure it exists before being added.
+`,
+	Args: cobra.ExactArgs(2),
+	RunE: runAddToolCmd,
+}
+
+func runAddToolCmd(cmd *cobra.Command, args []string) error {
+	filePath, _ := cmd.Flags().GetString("file")
+	if filePath != "" {
+		atmosConfig.Toolchain.FilePath = filePath
+	}
+	tool := args[0]
+	version := args[1]
+	// Call the business logic
+	if err := toolchain.AddToolVersion(tool, version); err != nil {
+		return err
+	}
+	return nil
+}
+
+func init() {
+	toolchainAddCmd.Flags().String("file", "", "Path to tool-versions file (defaults to global --tool-versions-file)")
+	_ = viper.BindEnv("toolchain.file_path", "TOOLCHAIN_PATH_RELATIVE", "ATMOS_TOOLCHAIN_PATH_RELATIVE")
+}

cmd/toolchain_aliases.go

@@ -0,0 +1,19 @@
+package cmd
+
+import (
+	"github.com/cloudposse/atmos/toolchain"
+	"github.com/spf13/cobra"
+)
+
+// toolchainAliasesCmd defines the Cobra command for listing aliases.
+var toolchainAliasesCmd = &cobra.Command{
+	Use:   "aliases",
+	Short: "List configured tool aliases",
+	Long: `List all configured tool aliases from the local tools.yaml configuration.
+
+Aliases allow you to use short tool names (like 'terraform') instead of
+full owner/repo paths (like 'hashicorp/terraform') in commands.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return toolchain.ListAliases()
+	},
+}

cmd/toolchain_clean.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/cloudposse/atmos/toolchain"
+	"github.com/spf13/cobra"
+)
+
+var toolchainCleanCmd = &cobra.Command{
+	Use:   "clean",
+	Short: "Remove all installed tools by deleting the .tools directory",
+	Long: `Remove all installed tools by deleting the .tools directory.
+
+This command will:
+- Count the number of files/directories in the .tools directory
+- Delete the entire .tools directory and all its contents
+- Display a summary of what was deleted
+
+Use this command to completely clean up all installed tools.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		toolsDir := atmosConfig.Toolchain.ToolsDir
+
+		homeDir, _ := os.UserHomeDir()
+		cacheDir := filepath.Join(homeDir, ".cache", "tools-cache")
+		tempCacheDir := filepath.Join(os.TempDir(), "tools-cache")
+
+		return toolchain.CleanToolsAndCaches(toolsDir, cacheDir, tempCacheDir)
+	},
+}

cmd/toolchain_exec.go

@@ -0,0 +1,21 @@
+package cmd
+
+import (
+	"github.com/cloudposse/atmos/toolchain"
+	"github.com/spf13/cobra"
+)
+
+var toolchainExecCmd = &cobra.Command{
+	Use:   "exec [tool[@version]] [flags...]",
+	Short: "Exec a specific version of a tool (replaces current process)",
+	Long: `Exec a specific version of a tool with arguments, replacing the current process.
+
+If no version is specified, the latest version will be used.
+`,
+	Args: cobra.MinimumNArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		installer := toolchain.NewInstaller()
+		return toolchain.RunExecCommand(installer, args)
+	},
+	DisableFlagParsing: true,
+}

cmd/toolchain_get.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/cloudposse/atmos/toolchain"
+	"github.com/spf13/cobra"
+)
+
+const defaultVersionsLimit = 50
+
+var toolchainVersionsCmd = &cobra.Command{
+	Use:   "versions <tool>",
+	Short: "List available or configured versions for a tool",
+	Args:  cobra.ExactArgs(1), // Requires exactly one argument (tool name)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		filePath, _ := cmd.Flags().GetString("file")
+		showAll, _ := cmd.Flags().GetBool("all")
+		limit, _ := cmd.Flags().GetInt("limit")
+		toolName := args[0]
+		if filePath != "" {
+			atmosConfig.Toolchain.FilePath = filePath
+		}
+		toolchain.SetAtmosConfig(&atmosConfig)
+		return toolchain.ListToolVersions(showAll, limit, toolName)
+	},
+}
+
+func init() {
+	toolchainVersionsCmd.Flags().String("file", "", "Path to tool-versions file (defaults to global --tool-versions-file)")
+	toolchainVersionsCmd.Flags().Bool("all", false, "Fetch all available versions from GitHub API")
+	toolchainVersionsCmd.Flags().Int("limit", defaultVersionsLimit, "Maximum number of versions to fetch when using --all")
+}