fix: skip config loading for __complete command

The __complete command is cobra's internal hidden command used for
shell autocompletion (triggered when user presses Tab). It was not
included in the skip list after PR #109, causing autocompletion to
fail outside project directories.

Bug reproduction:
  $ talm __complete ini ""
  error loading configuration: error reading configuration file: open Chart.yaml: no such file or directory

Changes:
- Add "__complete" to skipConfigCommands list
- Extract command list to a variable for testability and documentation
- Add unit tests for isCommandOrParent and skipConfigCommands

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: ZverGuy <maximbel2003@gmail.com>

Author: 2 people

main.go

@@ -19,6 +19,12 @@ import (
 
 var Version = "dev"
 
+// skipConfigCommands lists commands that should not load Chart.yaml config.
+// - init: creates the config, so it doesn't exist yet
+// - completion: generates shell completion scripts
+// - __complete: cobra's internal command for shell autocompletion (Tab key)
+var skipConfigCommands = []string{"init", "completion", "__complete"}
+
 // rootCmd represents the base command when called without any subcommands.
 var rootCmd = &cobra.Command{
 	Use:               "talm",
@@ -87,7 +93,7 @@ func init() {
 		}
 
 		// Load config after root detection (skip for init and completion commands)
-		if !isCommandOrParent(cmd, "init", "completion") {
+		if !isCommandOrParent(cmd, skipConfigCommands...) {
 			configFile := filepath.Join(commands.Config.RootDir, "Chart.yaml")
 			if err := loadConfig(configFile); err != nil {
 				return fmt.Errorf("error loading configuration: %w", err)

main_test.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+// buildCommandHierarchy creates a cobra command hierarchy from a path like
+// ["talm", "completion", "bash"] and returns the leaf command.
+func buildCommandHierarchy(path []string) *cobra.Command {
+	if len(path) == 0 {
+		return nil
+	}
+
+	root := &cobra.Command{Use: path[0]}
+	parent := root
+
+	for _, name := range path[1:] {
+		child := &cobra.Command{Use: name}
+		parent.AddCommand(child)
+		parent = child
+	}
+
+	return parent
+}
+
+func TestIsCommandOrParent(t *testing.T) {
+	tests := []struct {
+		name     string
+		cmdPath  []string
+		names    []string
+		expected bool
+	}{
+		{
+			name:     "direct completion command",
+			cmdPath:  []string{"talm", "completion"},
+			names:    []string{"init", "completion"},
+			expected: true,
+		},
+		{
+			name:     "completion bash subcommand",
+			cmdPath:  []string{"talm", "completion", "bash"},
+			names:    []string{"init", "completion"},
+			expected: true,
+		},
+		{
+			name:     "init command",
+			cmdPath:  []string{"talm", "init"},
+			names:    []string{"init", "completion"},
+			expected: true,
+		},
+		{
+			name:     "apply command should not match",
+			cmdPath:  []string{"talm", "apply"},
+			names:    []string{"init", "completion"},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			leaf := buildCommandHierarchy(tt.cmdPath)
+			result := isCommandOrParent(leaf, tt.names...)
+			if result != tt.expected {
+				t.Errorf("isCommandOrParent() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestSkipConfigCommands(t *testing.T) {
+	tests := []struct {
+		name     string
+		cmdPath  []string
+		expected bool // true = should skip config loading
+	}{
+		{
+			name:     "completion command",
+			cmdPath:  []string{"talm", "completion"},
+			expected: true,
+		},
+		{
+			name:     "completion bash",
+			cmdPath:  []string{"talm", "completion", "bash"},
+			expected: true,
+		},
+		{
+			name:     "completion zsh",
+			cmdPath:  []string{"talm", "completion", "zsh"},
+			expected: true,
+		},
+		{
+			name:     "__complete (cobra internal for shell autocompletion)",
+			cmdPath:  []string{"talm", "__complete"},
+			expected: true,
+		},
+		{
+			name:     "init command",
+			cmdPath:  []string{"talm", "init"},
+			expected: true,
+		},
+		{
+			name:     "apply command should load config",
+			cmdPath:  []string{"talm", "apply"},
+			expected: false,
+		},
+		{
+			name:     "template command should load config",
+			cmdPath:  []string{"talm", "template"},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			leaf := buildCommandHierarchy(tt.cmdPath)
+			// This uses the actual skipConfigCommands from main.go
+			result := isCommandOrParent(leaf, skipConfigCommands...)
+			if result != tt.expected {
+				t.Errorf("skipConfigCommands check = %v, want %v (skipConfigCommands = %v)",
+					result, tt.expected, skipConfigCommands)
+			}
+		})
+	}
+}