بناء تطبيقات CLI في Go باستخدام Cobra و Viper

go mod init myapp
go get -u github.com/spf13/cobra@latest
go get -u github.com/spf13/viper@latest

go install github.com/spf13/cobra-cli@latest

// main.go
package main

import "mytasks/cmd"

func main() {
    cmd.Execute()
}

// cmd/root.go
package cmd

import (
    "fmt"
    "os"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var cfgFile string

var rootCmd = &cobra.Command{
    Use:   "mytasks",
    Short: "أداة إدارة المهام البسيطة",
    Long: `MyTasks هي أداة إدارة المهام من سطر الأوامر التي تساعدك على تنظيم 
مهامك اليومية بسهولة. تم بناؤها باستخدام Cobra و Viper.`,
}

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}

func init() {
    cobra.OnInitialize(initConfig)
    
    rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", 
        "ملف التكوين (الافتراضي هو $HOME/.mytasks.yaml)")
    rootCmd.PersistentFlags().String("db", "", 
        "موقع ملف قاعدة البيانات")
    
    viper.BindPFlag("database", rootCmd.PersistentFlags().Lookup("db"))
}

func initConfig() {
    if cfgFile != "" {
        viper.SetConfigFile(cfgFile)
    } else {
        home, err := os.UserHomeDir()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
            os.Exit(1)
        }
        
        viper.AddConfigPath(home)
        viper.AddConfigPath(".")
        viper.SetConfigType("yaml")
        viper.SetConfigName(".mytasks")
    }
    
    viper.SetEnvPrefix("MYTASKS")
    viper.AutomaticEnv()
    
    if err := viper.ReadInConfig(); err == nil {
        fmt.Println("يتم استخدام ملف التكوين:", viper.ConfigFileUsed())
    }
}

// cmd/add.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var priority string

var addCmd = &cobra.Command{
    Use:   "add [وصف المهمة]",
    Short: "إضافة مهمة جديدة",
    Args:  cobra.MinimumNArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        task := args[0]
        db := viper.GetString("database")
        
        fmt.Printf("إضافة مهمة: %s\n", task)
        fmt.Printf("الأولوية: %s\n", priority)
        fmt.Printf("قاعدة البيانات: %s\n", db)
        
        // هنا ستقوم بتنفيذ تخزين المهام الفعلي
    },
}

func init() {
    rootCmd.AddCommand(addCmd)
    
    addCmd.Flags().StringVarP(&priority, "priority", "p", "medium", 
        "الأولوية (منخفضة، متوسطة، عالية)")
}

// cmd/list.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var showCompleted bool

var listCmd = &cobra.Command{
    Use:   "list",
    Short: "عرض جميع المهام",
    Run: func(cmd *cobra.Command, args []string) {
        db := viper.GetString("database")
        
        fmt.Printf("عرض المهام من: %s\n", db)
        fmt.Printf("عرض المهام المكتملة: %v\n", showCompleted)
        
        // هنا ستقوم بتنفيذ عرض المهام الفعلي
    },
}

func init() {
    rootCmd.AddCommand(listCmd)
    
    listCmd.Flags().BoolVarP(&showCompleted, "completed", "c", false, 
        "عرض المهام المكتملة")
}

# .mytasks.yaml
database: ~/.mytasks.db
format: table
colors: true

notifications:
  enabled: true
  sound: true

priorities:
  high: red
  medium: yellow
  low: green

func getNotificationSettings() {
    enabled := viper.GetBool("notifications.enabled")
    sound := viper.GetBool("notifications.sound")
    
    fmt.Printf("الإشعارات مفعلة: %v\n", enabled)
    fmt.Printf("الصوت مفعل: %v\n", sound)
}

func getPriorityColors() map[string]string {
    return viper.GetStringMapString("priorities")
}

export MYTASKS_DATABASE=/tmp/tasks.db
export MYTASKS_NOTIFICATIONS_ENABLED=false
mytasks list

func watchConfig() {
    viper.WatchConfig()
    viper.OnConfigChange(func(e fsnotify.Event) {
        fmt.Println("تم تغيير ملف التكوين:", e.Name)
        // إعادة تحميل المكونات المعتمدة على التكوين
    })
}

cobra-cli init
cobra-cli add serve
cobra-cli add create

rootCmd.PersistentFlags().StringP("output", "o", "text", 
    "نوع الإخراج (نص، json، yaml)")

var rootCmd = &cobra.Command{
    Use:   "myapp",
    Short: "تطبيقي",
    RunE: func(cmd *cobra.Command, args []string) error {
        if err := doSomething(); err != nil {
            return fmt.Errorf("فشل في تنفيذ شيء ما: %w", err)
        }
        return nil
    },
}

var cmd = &cobra.Command{
    Use:   "deploy [environment]",
    Short: "نشر التطبيق إلى البيئة المحددة",
    Long: `نشر البناء ونشر التطبيق إلى البيئة 
المحددة. البيئات المدعومة هي:
  - التطوير (dev)
  - التصحيح
  - الإنتاج (prod)`,
    Example: `  myapp deploy staging
  myapp deploy production --version=1.2.3`,
}

func init() {
    viper.SetDefault("port", 8080)
    viper.SetDefault("timeout", "30s")
    viper.SetDefault("retries", 3)
}

func validateConfig() error {
    port := viper.GetInt("port")
    if port < 1024 || port > 65535 {
        return fmt.Errorf("منفذ غير صحيح: %d", port)
    }
    return nil
}

// cmd/root_test.go
package cmd

import (
    "bytes"
    "testing"
)

func TestRootCommand(t *testing.T) {
    cmd := rootCmd
    b := bytes.NewBufferString("")
    cmd.SetOut(b)
    cmd.SetArgs([]string{"--help"})
    
    if err := cmd.Execute(); err != nil {
        t.Fatalf("فشل تنفيذ الأمر: %v", err)
    }
}

func TestWithConfig(t *testing.T) {
    viper.Set("database", "/tmp/test.db")
    viper.Set("debug", true)
    
    // قم بتشغيل اختباراتك
    
    viper.Reset() // التنظيف
}

// cmd/completion.go
package cmd

import (
    "os"
    "github.com/spf13/cobra"
)

var completionCmd = &cobra.Command{
    Use:   "completion [bash|zsh|fish|powershell]",
    Short: "إنشاء نص إكمال",
    Long: `لتحميل الإكمال:

Bash:
  $ source <(mytasks completion bash)

Zsh:
  $ source <(mytasks completion zsh)

Fish:
  $ mytasks completion fish | source

PowerShell:
  PS> mytasks completion powershell | Out-String | Invoke-Expression
`,
    DisableFlagsInUseLine: true,
    ValidArgs: []string{"bash", "zsh", "fish", "powershell"},
    Args: cobra.ExactValidArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        switch args[0] {
        case "bash":
            cmd.Root().GenBashCompletion(os.Stdout)
        case "zsh":
            cmd.Root().GenZshCompletion(os.Stdout)
        case "fish":
            cmd.Root().GenFishCompletion(os.Stdout, true)
        case "powershell":
            cmd.Root().GenPowerShellCompletionWithDesc(os.Stdout)
        }
    },
}

func init() {
    rootCmd.AddCommand(completionCmd)
}

# Linux
GOOS=linux GOARCH=amd64 go build -o mytasks-linux-amd64

# macOS
GOOS=darwin GOARCH=amd64 go build -o mytasks-darwin-amd64
GOOS=darwin GOARCH=arm64 go build -o mytasks-darwin-arm64

# Windows
GOOS=windows GOARCH=amd64 go build -o mytasks-windows-amd64.exe

go build -ldflags="-s -w" -o mytasks

// cmd/version.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
)

var (
    Version   = "dev"
    Commit    = "none"
    BuildTime = "unknown"
)

var versionCmd = &cobra.Command{
    Use:   "version",
    Short: "عرض معلومات الإصدار",
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Printf("الإصدار: %s\n", Version)
        fmt.Printf("الالتزام: %s\n", Commit)
        fmt.Printf("البناء: %s\n", BuildTime)
    },
}

func init() {
    rootCmd.AddCommand(versionCmd)
}

go build -ldflags="-X 'mytasks/cmd.Version=1.0.0' \
    -X 'mytasks/cmd.Commit=$(git rev-parse HEAD)' \
    -X 'mytasks/cmd.BuildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)'" \
    -o mytasks