## 🎯 왜 CLI 도구를 만들어야 할까? 안녕! 오늘은 Go언어로 멋진 CLI(Command Line Interface) 애플리케이션을 만드는 방법에 대해 이야기해볼게. 혹시 터미널에서 git, docker, kubectl 같은 명령어를 사용해본 적 있지? 이런 강력한 도구들이 바로 CLI 애플리케이션이야. 😎 요즘 개발자들 사이에서 CLI 도구는 정말 핫한 주제야. GUI보다 빠르고, 자동화하기 쉽고, 서버 환경에서도 완벽하게 동작하거든. 특히 DevOps나 자동화 작업을 할 때는 필수적이지! ## 🔥 Go언어가 CLI 개발에 최적인 이유 Go언어는 CLI 도구를 만들기에 정말 완벽한 언어야. 구글에서 만든 이 언어는 단순함과 성능을 동시에 잡았거든. 🎪 **첫째, 단일 바이너리 배포**가 가능해. Python이나 Node.js처럼 런타임을 따로 설치할 필요가 없어. 컴파일하면 하나의 실행 파일이 나오는데, 이걸 그냥 복사해서 어디서든 실행할 수 있어. 정말 편하지? **둘째, 크로스 컴파일**이 너무 쉬워. Windows에서 개발하면서 Linux용 바이너리를 만들 수 있고, Mac에서 Windows용을 만들 수도 있어. 환경변수 몇 개만 설정하면 끝이야! **셋째, 빠른 실행 속도**. C언어만큼은 아니지만, 스크립트 언어들보다 훨씬 빠르고 메모리도 적게 먹어. 대용량 데이터를 처리하는 CLI 도구를 만들 때 이 차이가 확 느껴져. **넷째, 동시성 처리**가 언어 차원에서 지원돼. 고루틴(Goroutine)을 사용하면 병렬 작업을 정말 쉽게 구현할 수 있어. 여러 파일을 동시에 처리하거나, API를 병렬로 호출하는 작업이 간단해지지. ## 🐍 Cobra 라이브러리 완전 정복 자, 이제 본격적으로 Cobra에 대해 알아볼까? Cobra는 Go에서 CLI 애플리케이션을 만들 때 가장 많이 사용되는 라이브러리야. Kubernetes, Hugo, GitHub CLI 같은 유명한 프로젝트들이 모두 Cobra를 사용하고 있어! 💪 ### Cobra가 제공하는 핵심 기능 Cobra는 정말 많은 기능을 제공하는데, 하나씩 살펴보자: ### Cobra 설치하고 시작하기 먼저 Cobra를 설치해보자. 터미널을 열고 다음 명령어를 입력해:

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

설치가 완료되면 새로운 CLI 프로젝트를 시작할 수 있어. Cobra CLI 도구를 사용하면 프로젝트 구조를 자동으로 만들어줘:

mkdir myapp
cd myapp
go mod init myapp
cobra-cli init

이 명령어를 실행하면 다음과 같은 구조가 생성돼:

myapp/
├── cmd/
│   └── root.go
├── main.go
└── go.mod

root.go 파일이 핵심이야. 여기에 루트 커맨드가 정의되어 있고, 모든 서브커맨드들이 이 루트에 연결되지. ### 첫 번째 CLI 애플리케이션 만들기 간단한 예제로 시작해보자. 사용자에게 인사하는 CLI 도구를 만들어볼게:

package main

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

var rootCmd = &cobra.Command{
    Use:   "greet",
    Short: "인사를 건네는 CLI 도구",
    Long:  `이름을 입력하면 친근하게 인사해주는 간단한 도구입니다.`,
    Run: func(cmd *cobra.Command, args []string) {
        name, _ := cmd.Flags().GetString("name")
        if name == "" {
            name = "친구"
        }
        fmt.Printf("안녕하세요, %s님! 😊\n", name)
    },
}

func init() {
    rootCmd.Flags().StringP("name", "n", "", "인사할 대상의 이름")
}

func main() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}

이 코드를 실행하면:

go run main.go --name 철수
# 출력: 안녕하세요, 철수님! 😊

go run main.go -n 영희
# 출력: 안녕하세요, 영희님! 😊

go run main.go
# 출력: 안녕하세요, 친구님! 😊

짧은 플래그(-n)와 긴 플래그(--name) 둘 다 자동으로 작동하는 게 보이지? 이게 Cobra의 매력이야! 🎉 ### 서브커맨드 추가하기 이제 좀 더 복잡한 구조를 만들어보자. 서브커맨드를 추가하는 방법을 알아볼게:

cobra-cli add hello
cobra-cli add goodbye

이 명령어를 실행하면 cmd/hello.go와 cmd/goodbye.go 파일이 생성돼. 각 파일을 수정해서 기능을 추가할 수 있어:

// cmd/hello.go
package cmd

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

var helloCmd = &cobra.Command{
    Use:   "hello [이름]",
    Short: "반갑게 인사합니다",
    Args:  cobra.MinimumNArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        enthusiastic, _ := cmd.Flags().GetBool("enthusiastic")
        name := args[0]
        
        if enthusiastic {
            fmt.Printf("안녕하세요, %s님!!! 정말 반갑습니다!!! 🎉🎉🎉\n", name)
        } else {
            fmt.Printf("안녕하세요, %s님. 반갑습니다.\n", name)
        }
    },
}

func init() {
    rootCmd.AddCommand(helloCmd)
    helloCmd.Flags().BoolP("enthusiastic", "e", false, "열정적으로 인사하기")
}

이제 다음과 같이 사용할 수 있어:

go run main.go hello 민수
# 출력: 안녕하세요, 민수님. 반갑습니다.

go run main.go hello 민수 --enthusiastic
# 출력: 안녕하세요, 민수님!!! 정말 반갑습니다!!! 🎉🎉🎉

## 🔧 Viper로 설정 관리 마스터하기 CLI 도구를 만들다 보면 설정을 관리해야 할 일이 많아. 사용자마다 다른 API 키를 사용한다거나, 기본 동작을 커스터마이징하고 싶을 때 말이야. 이때 Viper가 정말 유용해! 🎯 Viper는 Cobra를 만든 같은 팀에서 개발한 설정 관리 라이브러리야. 여러 소스에서 설정을 읽어올 수 있어: - JSON, YAML, TOML, HCL 등의 설정 파일 - 환경 변수 - 커맨드 라인 플래그 - 원격 설정 시스템 (etcd, Consul 등) ### Viper 설치 및 기본 사용법 먼저 Viper를 설치하자:

go get github.com/spf13/viper

기본적인 사용 예제를 보자:

package main

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

func main() {
    // 설정 파일 이름과 경로 지정
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")
    viper.AddConfigPath("$HOME/.myapp")
    
    // 설정 파일 읽기
    if err := viper.ReadInConfig(); err != nil {
        fmt.Printf("설정 파일을 찾을 수 없습니다: %v\n", err)
    }
    
    // 설정 값 읽기
    apiKey := viper.GetString("api.key")
    timeout := viper.GetInt("timeout")
    debug := viper.GetBool("debug")
    
    fmt.Printf("API Key: %s\n", apiKey)
    fmt.Printf("Timeout: %d\n", timeout)
    fmt.Printf("Debug: %v\n", debug)
}

그리고 config.yaml 파일을 만들어:

api:
  key: "your-secret-api-key"
  endpoint: "https://api.example.com"

timeout: 30
debug: true
retries: 3

### Cobra와 Viper 통합하기 Cobra와 Viper를 함께 사용하면 정말 강력한 조합이 돼. 플래그, 설정 파일, 환경 변수를 모두 통합해서 관리할 수 있거든:

package cmd

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

var cfgFile string

var rootCmd = &cobra.Command{
    Use:   "myapp",
    Short: "설정 관리가 완벽한 CLI 도구",
}

func init() {
    cobra.OnInitialize(initConfig)
    
    rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", 
        "설정 파일 경로 (기본값: $HOME/.myapp.yaml)")
    rootCmd.PersistentFlags().Bool("debug", false, "디버그 모드 활성화")
    
    // 플래그를 Viper에 바인딩
    viper.BindPFlag("debug", rootCmd.PersistentFlags().Lookup("debug"))
}

func initConfig() {
    if cfgFile != "" {
        viper.SetConfigFile(cfgFile)
    } else {
        viper.AddConfigPath("$HOME")
        viper.SetConfigName(".myapp")
        viper.SetConfigType("yaml")
    }
    
    // 환경 변수 자동 바인딩
    viper.AutomaticEnv()
    
    if err := viper.ReadInConfig(); err == nil {
        fmt.Println("설정 파일 사용:", viper.ConfigFileUsed())
    }
}

이렇게 설정하면 우선순위가 다음과 같이 적용돼: 1. **커맨드 라인 플래그** (가장 높은 우선순위) 2. **환경 변수** 3. **설정 파일** 4. **기본값** (가장 낮은 우선순위) ### 중첩된 설정 다루기 복잡한 애플리케이션에서는 설정이 계층적으로 구성되는 경우가 많아. Viper는 이런 중첩 구조도 쉽게 다룰 수 있어:

# config.yaml
database:
  host: localhost
  port: 5432
  credentials:
    username: admin
    password: secret
  pool:
    max_connections: 100
    min_connections: 10

server:
  host: 0.0.0.0
  port: 8080
  tls:
    enabled: true
    cert_file: /path/to/cert.pem
    key_file: /path/to/key.pem

Go 코드에서는 이렇게 접근해:

// 점(.) 표기법으로 중첩된 값 접근
dbHost := viper.GetString("database.host")
dbPort := viper.GetInt("database.port")
username := viper.GetString("database.credentials.username")
maxConn := viper.GetInt("database.pool.max_connections")

// 전체 섹션을 맵으로 가져오기
dbConfig := viper.GetStringMap("database")
fmt.Printf("Database config: %v\n", dbConfig)

// 구조체로 언마샬링
type DatabaseConfig struct {
    Host string
    Port int
    Credentials struct {
        Username string
        Password string
    }
    Pool struct {
        MaxConnections int `mapstructure:"max_connections"`
        MinConnections int `mapstructure:"min_connections"`
    }
}

var dbCfg DatabaseConfig
viper.UnmarshalKey("database", &dbCfg)

### 동적 설정 변경 감지 Viper의 멋진 기능 중 하나는 설정 파일의 변경을 실시간으로 감지할 수 있다는 거야. 애플리케이션을 재시작하지 않고도 설정을 업데이트할 수 있어:

viper.WatchConfig()
viper.OnConfigChange(func(e fsnotify.Event) {
    fmt.Println("설정 파일이 변경되었습니다:", e.Name)
    
    // 새로운 설정 값 적용
    newTimeout := viper.GetInt("timeout")
    fmt.Printf("새로운 타임아웃 값: %d\n", newTimeout)
    
    // 여기서 애플리케이션 동작을 업데이트
    updateApplicationConfig()
})

이 기능은 장시간 실행되는 서비스나 데몬 프로세스에서 특히 유용해. 설정을 바꾸고 싶을 때마다 서비스를 재시작할 필요가 없으니까! ## 🎨 실전 프로젝트: 파일 관리 CLI 도구 만들기 이론은 충분히 배웠으니, 이제 실제로 유용한 CLI 도구를 만들어보자! 파일을 검색하고, 정리하고, 분석하는 도구를 만들 거야. 이름은 filemaster로 하자! 📂 ### 프로젝트 구조 설계 먼저 프로젝트 구조를 잡아보자:

filemaster/
├── cmd/
│   ├── root.go
│   ├── search.go
│   ├── organize.go
│   └── analyze.go
├── internal/
│   ├── file/
│   │   ├── search.go
│   │   ├── organize.go
│   │   └── analyze.go
│   └── config/
│       └── config.go
├── config.yaml
├── main.go
└── go.mod

이 구조는 관심사의 분리(Separation of Concerns) 원칙을 따라. cmd 패키지는 CLI 인터페이스만 담당하고, 실제 비즈니스 로직은 internal 패키지에 분리했어. ### Root 커맨드 구현 먼저 루트 커맨드를 만들자:

// cmd/root.go
package cmd

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

var cfgFile string
var verbose bool

var rootCmd = &cobra.Command{
    Use:   "filemaster",
    Short: "강력한 파일 관리 CLI 도구",
    Long: `filemaster는 파일을 검색하고, 정리하고, 분석하는 
올인원 CLI 도구입니다. 대용량 파일 시스템도 빠르게 처리할 수 있어요!`,
}

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/.filemaster.yaml)")
    rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, 
        "상세한 출력 표시")
    
    viper.BindPFlag("verbose", rootCmd.PersistentFlags().Lookup("verbose"))
}

func initConfig() {
    if cfgFile != "" {
        viper.SetConfigFile(cfgFile)
    } else {
        home, err := os.UserHomeDir()
        if err != nil {
            fmt.Println(err)
            os.Exit(1)
        }
        
        viper.AddConfigPath(home)
        viper.AddConfigPath(".")
        viper.SetConfigName(".filemaster")
        viper.SetConfigType("yaml")
    }
    
    viper.AutomaticEnv()
    
    if err := viper.ReadInConfig(); err == nil && verbose {
        fmt.Println("설정 파일 사용:", viper.ConfigFileUsed())
    }
}

### Search 커맨드 구현 파일을 검색하는 기능을 만들어보자. 이름, 확장자, 크기 등으로 검색할 수 있게 할 거야:

// cmd/search.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "filemaster/internal/file"
)

var searchCmd = &cobra.Command{
    Use:   "search [경로]",
    Short: "파일 검색",
    Long:  `지정된 경로에서 조건에 맞는 파일을 검색합니다.`,
    Args:  cobra.ExactArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        path := args[0]
        
        pattern, _ := cmd.Flags().GetString("pattern")
        ext, _ := cmd.Flags().GetString("ext")
        minSize, _ := cmd.Flags().GetInt64("min-size")
        maxSize, _ := cmd.Flags().GetInt64("max-size")
        
        opts := file.SearchOptions{
            Pattern: pattern,
            Extension: ext,
            MinSize: minSize,
            MaxSize: maxSize,
        }
        
        results, err := file.Search(path, opts)
        if err != nil {
            fmt.Printf("검색 중 오류 발생: %v\n", err)
            return
        }
        
        fmt.Printf("총 %d개의 파일을 찾았습니다:\n\n", len(results))
        for _, result := range results {
            fmt.Printf("📄 %s (%s)\n", result.Path, formatSize(result.Size))
        }
    },
}

func init() {
    rootCmd.AddCommand(searchCmd)
    
    searchCmd.Flags().StringP("pattern", "p", "", "파일명 패턴 (정규식)")
    searchCmd.Flags().StringP("ext", "e", "", "파일 확장자")
    searchCmd.Flags().Int64("min-size", 0, "최소 파일 크기 (바이트)")
    searchCmd.Flags().Int64("max-size", 0, "최대 파일 크기 (바이트)")
}

func formatSize(bytes int64) string {
    const unit = 1024
    if bytes < unit {
        return fmt.Sprintf("%d B", bytes)
    }
    div, exp := int64(unit), 0
    for n := bytes / unit; n >= unit; n /= unit {
        div *= unit
        exp++
    }
    return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
}

### 실제 검색 로직 구현 이제 internal 패키지에 실제 검색 로직을 구현하자:

// internal/file/search.go
package file

import (
    "os"
    "path/filepath"
    "regexp"
    "strings"
)

type SearchOptions struct {
    Pattern   string
    Extension string
    MinSize   int64
    MaxSize   int64
}

type SearchResult struct {
    Path string
    Size int64
    IsDir bool
}

func Search(root string, opts SearchOptions) ([]SearchResult, error) {
    var results []SearchResult
    var pattern *regexp.Regexp
    var err error
    
    if opts.Pattern != "" {
        pattern, err = regexp.Compile(opts.Pattern)
        if err != nil {
            return nil, err
        }
    }
    
    err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return nil // 에러가 있어도 계속 진행
        }
        
        // 디렉토리는 건너뛰기
        if info.IsDir() {
            return nil
        }
        
        // 패턴 매칭
        if pattern != nil && !pattern.MatchString(filepath.Base(path)) {
            return nil
        }
        
        // 확장자 필터링
        if opts.Extension != "" {
            ext := strings.TrimPrefix(filepath.Ext(path), ".")
            if ext != opts.Extension {
                return nil
            }
        }
        
        // 크기 필터링
        size := info.Size()
        if opts.MinSize > 0 && size < opts.MinSize {
            return nil
        }
        if opts.MaxSize > 0 && size > opts.MaxSize {
            return nil
        }
        
        results = append(results, SearchResult{
            Path: path,
            Size: size,
            IsDir: false,
        })
        
        return nil
    })
    
    return results, err
}

### Organize 커맨드로 파일 정리하기 이제 파일을 확장자별로 정리하는 기능을 추가해보자:

// cmd/organize.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "filemaster/internal/file"
)

var organizeCmd = &cobra.Command{
    Use:   "organize [경로]",
    Short: "파일 정리",
    Long:  `파일을 확장자별로 폴더에 정리합니다.`,
    Args:  cobra.ExactArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        path := args[0]
        
        dryRun, _ := cmd.Flags().GetBool("dry-run")
        byDate, _ := cmd.Flags().GetBool("by-date")
        
        opts := file.OrganizeOptions{
            DryRun: dryRun,
            ByDate: byDate,
        }
        
        result, err := file.Organize(path, opts)
        if err != nil {
            fmt.Printf("정리 중 오류 발생: %v\n", err)
            return
        }
        
        if dryRun {
            fmt.Println("🔍 시뮬레이션 모드 (실제로 파일을 이동하지 않습니다)")
        }
        
        fmt.Printf("\n✨ 정리 완료!\n")
        fmt.Printf("이동된 파일: %d개\n", result.MovedFiles)
        fmt.Printf("생성된 폴더: %d개\n", result.CreatedDirs)
        
        if len(result.Errors) > 0 {
            fmt.Printf("\n⚠️  %d개의 오류 발생:\n", len(result.Errors))
            for _, err := range result.Errors {
                fmt.Printf("  - %v\n", err)
            }
        }
    },
}

func init() {
    rootCmd.AddCommand(organizeCmd)
    
    organizeCmd.Flags().Bool("dry-run", false, "실제로 이동하지 않고 시뮬레이션만")
    organizeCmd.Flags().Bool("by-date", false, "날짜별로 정리")
}

### Analyze 커맨드로 통계 분석하기 마지막으로 디렉토리의 파일 통계를 분석하는 기능을 추가하자:

// cmd/analyze.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "filemaster/internal/file"
    "sort"
)

var analyzeCmd = &cobra.Command{
    Use:   "analyze [경로]",
    Short: "파일 분석",
    Long:  `디렉토리의 파일 통계를 분석합니다.`,
    Args:  cobra.ExactArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        path := args[0]
        
        showChart, _ := cmd.Flags().GetBool("chart")
        topN, _ := cmd.Flags().GetInt("top")
        
        stats, err := file.Analyze(path)
        if err != nil {
            fmt.Printf("분석 중 오류 발생: %v\n", err)
            return
        }
        
        fmt.Printf("\n📊 디렉토리 분석 결과: %s\n\n", path)
        fmt.Printf("총 파일 수: %d개\n", stats.TotalFiles)
        fmt.Printf("총 크기: %s\n", formatSize(stats.TotalSize))
        fmt.Printf("평균 파일 크기: %s\n\n", formatSize(stats.AverageSize))
        
        // 확장자별 통계
        fmt.Println("📁 확장자별 분포:")
        
        type extStat struct {
            ext   string
            count int
            size  int64
        }
        
        var extStats []extStat
        for ext, count := range stats.ExtensionCount {
            extStats = append(extStats, extStat{
                ext:   ext,
                count: count,
                size:  stats.ExtensionSize[ext],
            })
        }
        
        sort.Slice(extStats, func(i, j int) bool {
            return extStats[i].size > extStats[j].size
        })
        
        displayCount := topN
        if len(extStats) < displayCount {
            displayCount = len(extStats)
        }
        
        for i := 0; i < displayCount; i++ {
            stat := extStats[i]
            percentage := float64(stat.size) / float64(stats.TotalSize) * 100
            
            fmt.Printf("  .%-10s %4d개  %10s  (%.1f%%)\n", 
                stat.ext, stat.count, formatSize(stat.size), percentage)
            
            if showChart {
                barLength := int(percentage / 2)
                bar := strings.Repeat("█", barLength)
                fmt.Printf("             %s\n", bar)
            }
        }
        
        // 가장 큰 파일들
        fmt.Println("\n📦 가장 큰 파일들:")
        for i, f := range stats.LargestFiles {
            if i >= 5 {
                break
            }
            fmt.Printf("  %d. %s (%s)\n", i+1, f.Name, formatSize(f.Size))
        }
    },
}

func init() {
    rootCmd.AddCommand(analyzeCmd)
    
    analyzeCmd.Flags().Bool("chart", false, "차트 표시")
    analyzeCmd.Flags().IntP("top", "t", 10, "상위 N개 확장자 표시")
}

이제 이렇게 사용할 수 있어:

# 파일 검색
filemaster search ~/Documents --pattern "report.*\.pdf" --min-size 1048576

# 파일 정리 (시뮬레이션)
filemaster organize ~/Downloads --dry-run

# 파일 정리 (실제 실행)
filemaster organize ~/Downloads

# 디렉토리 분석
filemaster analyze ~/Projects --chart --top 5

## 🚀 고급 기능 구현하기 기본 기능은 다 만들었으니, 이제 좀 더 고급 기능들을 추가해보자. 프로페셔널한 CLI 도구가 되려면 이런 기능들이 필요해! ### 진행 상황 표시하기 대용량 파일을 처리할 때는 진행 상황을 보여주는 게 중요해. 사용자가 프로그램이 멈춘 건지 아니면 열심히 작동 중인지 알 수 있어야 하거든. progressbar 라이브러리를 사용하면 쉽게 구현할 수 있어:

go get github.com/schollz/progressbar/v3

package file

import (
    "github.com/schollz/progressbar/v3"
    "os"
    "path/filepath"
)

func SearchWithProgress(root string, opts SearchOptions) ([]SearchResult, error) {
    // 먼저 총 파일 수를 세기
    var totalFiles int
    filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
        if err == nil && !info.IsDir() {
            totalFiles++
        }
        return nil
    })
    
    // 프로그레스 바 생성
    bar := progressbar.NewOptions(totalFiles,
        progressbar.OptionSetDescription("파일 검색 중..."),
        progressbar.OptionSetTheme(progressbar.Theme{
            Saucer:        "=",
            SaucerHead:    ">",
            SaucerPadding: " ",
            BarStart:      "[",
            BarEnd:        "]",
        }),
        progressbar.OptionShowCount(),
        progressbar.OptionShowIts(),
        progressbar.OptionSetWidth(50),
    )
    
    var results []SearchResult
    
    err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return nil
        }
        
        if !info.IsDir() {
            bar.Add(1)
            
            // 검색 로직...
            if matchesOptions(path, info, opts) {
                results = append(results, SearchResult{
                    Path: path,
                    Size: info.Size(),
                })
            }
        }
        
        return nil
    })
    
    bar.Finish()
    return results, err
}

### 병렬 처리로 성능 향상하기 Go의 강점인 고루틴을 활용해서 파일 처리를 병렬화하면 성능이 크게 향상돼. 특히 많은 파일을 처리할 때 효과가 좋아:

package file

import (
    "sync"
    "runtime"
)

func AnalyzeParallel(root string) (*Stats, error) {
    numWorkers := runtime.NumCPU()
    
    // 작업 큐와 결과 채널
    jobs := make(chan string, 100)
    results := make(chan FileInfo, 100)
    
    // 워커 풀 생성
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for path := range jobs {
                info, err := analyzeFile(path)
                if err == nil {
                    results <- info
                }
            }
        }()
    }
    
    // 파일 목록 수집 및 작업 분배
    go func() {
        filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
            if err == nil && !info.IsDir() {
                jobs <- path
            }
            return nil
        })
        close(jobs)
    }()
    
    // 워커들이 완료되면 결과 채널 닫기
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // 결과 수집
    stats := &Stats{
        ExtensionCount: make(map[string]int),
        ExtensionSize:  make(map[string]int64),
    }
    
    for info := range results {
        stats.TotalFiles++
        stats.TotalSize += info.Size
        
        ext := filepath.Ext(info.Path)
        stats.ExtensionCount[ext]++
        stats.ExtensionSize[ext] += info.Size
    }
    
    if stats.TotalFiles > 0 {
        stats.AverageSize = stats.TotalSize / int64(stats.TotalFiles)
    }
    
    return stats, nil
}

### 컬러풀한 출력 만들기 터미널 출력에 색상을 추가하면 가독성이 훨씬 좋아져. fatih/color 패키지를 사용하면 간단해:

go get github.com/fatih/color

package cmd

import (
    "github.com/fatih/color"
    "fmt"
)

var (
    successColor = color.New(color.FgGreen, color.Bold)
    errorColor   = color.New(color.FgRed, color.Bold)
    warningColor = color.New(color.FgYellow, color.Bold)
    infoColor    = color.New(color.FgCyan)
    highlightColor = color.New(color.FgMagenta, color.Bold)
)

func printSuccess(msg string) {
    successColor.Printf("✓ %s\n", msg)
}

func printError(msg string) {
    errorColor.Printf("✗ %s\n", msg)
}

func printWarning(msg string) {
    warningColor.Printf("⚠ %s\n", msg)
}

func printInfo(msg string) {
    infoColor.Printf("ℹ %s\n", msg)
}

func printHighlight(msg string) {
    highlightColor.Println(msg)
}

// 사용 예시
func showResults(results []SearchResult) {
    if len(results) == 0 {
        printWarning("검색 결과가 없습니다")
        return
    }
    
    printSuccess(fmt.Sprintf("총 %d개의 파일을 찾았습니다", len(results)))
    
    for _, result := range results {
        infoColor.Printf("  📄 %s ", result.Path)
        highlightColor.Printf("(%s)\n", formatSize(result.Size))
    }
}

### 자동 완성 기능 추가하기 Cobra는 쉘 자동완성 스크립트를 자동으로 생성해줘. 사용자 경험이 훨씬 좋아지지:

// 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 <(filemaster completion bash)
    또는
    $ filemaster completion bash > /etc/bash_completion.d/filemaster

  Zsh:
    $ filemaster completion zsh > "${fpath[1]}/_filemaster"

  Fish:
    $ filemaster completion fish > ~/.config/fish/completions/filemaster.fish

  PowerShell:
    PS> filemaster 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)
}

사용자는 이렇게 설치할 수 있어:

# Bash
echo 'source <(filemaster completion bash)' >> ~/.bashrc

# Zsh
filemaster completion zsh > ~/.zsh/completion/_filemaster
echo 'fpath=(~/.zsh/completion $fpath)' >> ~/.zshrc

# Fish
filemaster completion fish > ~/.config/fish/completions/filemaster.fish

## 🧪 테스트와 디버깅 프로페셔널한 CLI 도구를 만들려면 테스트가 필수야. Go는 테스트 작성이 정말 쉬워! ### 유닛 테스트 작성하기

// internal/file/search_test.go
package file

import (
    "os"
    "path/filepath"
    "testing"
)

func TestSearch(t *testing.T) {
    // 테스트용 임시 디렉토리 생성
    tmpDir := t.TempDir()
    
    // 테스트 파일들 생성
    testFiles := []struct {
        name string
        size int64
    }{
        {"test1.txt", 100},
        {"test2.pdf", 1000},
        {"test3.txt", 500},
        {"large.bin", 10000},
    }
    
    for _, tf := range testFiles {
        path := filepath.Join(tmpDir, tf.name)
        f, err := os.Create(path)
        if err != nil {
            t.Fatal(err)
        }
        f.Truncate(tf.size)
        f.Close()
    }
    
    // 테스트 케이스들
    tests := []struct {
        name     string
        opts     SearchOptions
        expected int
    }{
        {
            name: "txt 파일만 검색",
            opts: SearchOptions{Extension: "txt"},
            expected: 2,
        },
        {
            name: "500바이트 이상 파일",
            opts: SearchOptions{MinSize: 500},
            expected: 3,
        },
        {
            name: "패턴 매칭",
            opts: SearchOptions{Pattern: "test[0-9]"},
            expected: 3,
        },
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            results, err := Search(tmpDir, tt.opts)
            if err != nil {
                t.Errorf("Search() error = %v", err)
                return
            }
            
            if len(results) != tt.expected {
                t.Errorf("Search() got %d results, want %d", 
                    len(results), tt.expected)
            }
        })
    }
}

func BenchmarkSearch(b *testing.B) {
    tmpDir := b.TempDir()
    
    // 벤치마크용 파일 생성
    for i := 0; i < 1000; i++ {
        path := filepath.Join(tmpDir, fmt.Sprintf("file%d.txt", i))
        os.Create(path)
    }
    
    opts := SearchOptions{Extension: "txt"}
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        Search(tmpDir, opts)
    }
}

테스트 실행:

# 모든 테스트 실행
go test ./...

# 커버리지 확인
go test -cover ./...

# 벤치마크 실행
go test -bench=. ./...

# 상세한 출력
go test -v ./...

### 통합 테스트 CLI 명령어 자체를 테스트하는 것도 중요해:

// cmd/root_test.go
package cmd

import (
    "bytes"
    "testing"
)

func TestRootCommand(t *testing.T) {
    // 출력 캡처를 위한 버퍼
    buf := new(bytes.Buffer)
    rootCmd.SetOut(buf)
    rootCmd.SetErr(buf)
    
    // 명령어 실행
    rootCmd.SetArgs([]string{"--help"})
    err := rootCmd.Execute()
    
    if err != nil {
        t.Errorf("rootCmd.Execute() error = %v", err)
    }
    
    output := buf.String()
    if !strings.Contains(output, "filemaster") {
        t.Error("Help output doesn't contain 'filemaster'")
    }
}

func TestSearchCommand(t *testing.T) {
    tmpDir := t.TempDir()
    
    // 테스트 파일 생성
    os.Create(filepath.Join(tmpDir, "test.txt"))
    
    buf := new(bytes.Buffer)
    rootCmd.SetOut(buf)
    
    rootCmd.SetArgs([]string{"search", tmpDir, "--ext", "txt"})
    err := rootCmd.Execute()
    
    if err != nil {
        t.Errorf("search command error = %v", err)
    }
    
    output := buf.String()
    if !strings.Contains(output, "test.txt") {
        t.Error("Search didn't find test.txt")
    }
}

## 📦 빌드와 배포 이제 완성된 CLI 도구를 빌드하고 배포해보자! ### 크로스 컴파일 Go의 가장 큰 장점 중 하나가 크로스 컴파일이야. 한 번에 여러 플랫폼용 바이너리를 만들 수 있어:

# Linux (64비트)
GOOS=linux GOARCH=amd64 go build -o filemaster-linux-amd64

# Windows (64비트)
GOOS=windows GOARCH=amd64 go build -o filemaster-windows-amd64.exe

# macOS (Intel)
GOOS=darwin GOARCH=amd64 go build -o filemaster-darwin-amd64

# macOS (Apple Silicon)
GOOS=darwin GOARCH=arm64 go build -o filemaster-darwin-arm64

# Linux (ARM, 라즈베리파이 등)
GOOS=linux GOARCH=arm GOARM=7 go build -o filemaster-linux-arm

### 빌드 스크립트 만들기 모든 플랫폼용 바이너리를 한 번에 빌드하는 스크립트를 만들자:

#!/bin/bash
# build.sh

VERSION="1.0.0"
APP_NAME="filemaster"

platforms=(
    "linux/amd64"
    "linux/arm64"
    "darwin/amd64"
    "darwin/arm64"
    "windows/amd64"
)

for platform in "${platforms[@]}"
do
    platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}
    
    output_name=$APP_NAME'-'$VERSION'-'$GOOS'-'$GOARCH
    
    if [ $GOOS = "windows" ]; then
        output_name+='.exe'
    fi
    
    echo "Building $output_name..."
    
    env GOOS=$GOOS GOARCH=$GOARCH go build \
        -ldflags="-s -w -X main.version=$VERSION" \
        -o dist/$output_name
    
    if [ $? -ne 0 ]; then
        echo "Failed to build $output_name"
        exit 1
    fi
done

echo "Build complete!"

### 바이너리 크기 최적화 Go 바이너리는 기본적으로 좀 큰 편이야. 하지만 최적화하면 크기를 많이 줄일 수 있어:

# 기본 빌드
go build -o filemaster

# 최적화된 빌드
go build -ldflags="-s -w" -o filemaster

# UPX로 추가 압축 (선택사항)
upx --best --lzma filemaster

빌드 옵션	설명	크기 감소
-s	심볼 테이블 제거	~10%
-w	DWARF 디버그 정보 제거	~20%
UPX	실행 파일 압축	~50-70%

### GitHub Releases로 배포하기 GitHub Actions를 사용하면 자동으로 릴리스를 만들 수 있어:

# .github/workflows/release.yml
name: Release

on:
  push:
    tags:
      - 'v*'

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: '1.21'
      
      - name: Run tests
        run: go test -v ./...
      
      - name: Build binaries
        run: |
          chmod +x build.sh
          ./build.sh
      
      - name: Create Release
        uses: softprops/action-gh-release@v1
        with:
          files: dist/*
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

이제 태그를 푸시하면 자동으로 릴리스가 생성돼:

git tag v1.0.0
git push origin v1.0.0

### Homebrew로 배포하기 (macOS) macOS 사용자들을 위해 Homebrew Formula를 만들 수도 있어:

# Formula/filemaster.rb
class Filemaster < Formula
  desc "강력한 파일 관리 CLI 도구"
  homepage "https://github.com/yourusername/filemaster"
  url "https://github.com/yourusername/filemaster/archive/v1.0.0.tar.gz"
  sha256 "your-sha256-hash"
  license "MIT"

  depends_on "go" => :build

  def install
    system "go", "build", *std_go_args(ldflags: "-s -w")
  end

  test do
    system "#{bin}/filemaster", "--version"
  end
end

사용자는 이렇게 설치할 수 있어:

brew tap yourusername/tap
brew install filemaster

## 🎓 실전 예제: 재능넷 API 클라이언트 만들기 이제 배운 내용을 활용해서 실제로 유용한 도구를 만들어보자! 재능넷의 API를 사용하는 CLI 클라이언트를 만들어볼게. 재능넷은 다양한 재능을 거래하는 플랫폼이니까, 재능 검색이나 등록을 CLI로 할 수 있으면 편리하겠지? 😊 ### 프로젝트 구조

jaenung-cli/
├── cmd/
│   ├── root.go
│   ├── search.go
│   ├── post.go
│   └── profile.go
├── internal/
│   ├── api/
│   │   └── client.go
│   └── config/
│       └── config.go
├── .jaenung.yaml
└── main.go

### API 클라이언트 구현 먼저 재능넷 API와 통신하는 클라이언트를 만들자:

// internal/api/client.go
package api

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

type Client struct {
    BaseURL    string
    APIKey     string
    HTTPClient *http.Client
}

type Talent struct {
    ID          int       `json:"id"`
    Title       string    `json:"title"`
    Description string    `json:"description"`
    Category    string    `json:"category"`
    Price       int       `json:"price"`
    Author      string    `json:"author"`
    CreatedAt   time.Time `json:"created_at"`
}

type SearchOptions struct {
    Query    string
    Category string
    MinPrice int
    MaxPrice int
    Limit    int
}

func NewClient(baseURL, apiKey string) *Client {
    return &Client{
        BaseURL: baseURL,
        APIKey:  apiKey,
        HTTPClient: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}

func (c *Client) SearchTalents(opts SearchOptions) ([]Talent, error) {
    url := fmt.Sprintf("%s/api/talents/search", c.BaseURL)
    
    params := map[string]interface{}{
        "query":     opts.Query,
        "category":  opts.Category,
        "min_price": opts.MinPrice,
        "max_price": opts.MaxPrice,
        "limit":     opts.Limit,
    }
    
    body, err := json.Marshal(params)
    if err != nil {
        return nil, err
    }
    
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s", string(body))
    }
    
    var talents []Talent
    if err := json.NewDecoder(resp.Body).Decode(&talents); err != nil {
        return nil, err
    }
    
    return talents, nil
}

func (c *Client) PostTalent(talent Talent) error {
    url := fmt.Sprintf("%s/api/talents", c.BaseURL)
    
    body, err := json.Marshal(talent)
    if err != nil {
        return err
    }
    
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
    if err != nil {
        return err
    }
    
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusCreated {
        body, _ := io.ReadAll(resp.Body)
        return fmt.Errorf("API error: %s", string(body))
    }
    
    return nil
}

### Search 커맨드 구현 재능을 검색하는 명령어를 만들자:

// cmd/search.go
package cmd

import (
    "fmt"
    "github.com/fatih/color"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
    "jaenung-cli/internal/api"
)

var searchCmd = &cobra.Command{
    Use:   "search [키워드]",
    Short: "재능넷에서 재능 검색",
    Long:  `키워드와 필터를 사용해서 재능넷에서 재능을 검색합니다.`,
    Args:  cobra.MinimumNArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        query := args[0]
        
        category, _ := cmd.Flags().GetString("category")
        minPrice, _ := cmd.Flags().GetInt("min-price")
        maxPrice, _ := cmd.Flags().GetInt("max-price")
        limit, _ := cmd.Flags().GetInt("limit")
        
        // API 클라이언트 생성
        client := api.NewClient(
            viper.GetString("api.base_url"),
            viper.GetString("api.key"),
        )
        
        // 검색 실행
        opts := api.SearchOptions{
            Query:    query,
            Category: category,
            MinPrice: minPrice,
            MaxPrice: maxPrice,
            Limit:    limit,
        }
        
        talents, err := client.SearchTalents(opts)
        if err != nil {
            color.Red("❌ 검색 실패: %v", err)
            return
        }
        
        // 결과 출력
        if len(talents) == 0 {
            color.Yellow("⚠️  검색 결과가 없습니다")
            return
        }
        
        color.Green("✓ %d개의 재능을 찾았습니다:\n", len(talents))
        
        for i, talent := range talents {
            fmt.Printf("\n%d. ", i+1)
            color.Cyan(talent.Title)
            fmt.Printf("   카테고리: %s | 가격: %s원\n", 
                talent.Category, 
                formatPrice(talent.Price))
            fmt.Printf("   작성자: %s\n", talent.Author)
            
            if viper.GetBool("verbose") {
                fmt.Printf("   설명: %s\n", talent.Description)
            }
        }
        
        fmt.Println("\n💡 상세 정보를 보려면 --verbose 플래그를 사용하세요")
    },
}

func init() {
    rootCmd.AddCommand(searchCmd)
    
    searchCmd.Flags().StringP("category", "c", "", "카테고리 필터")
    searchCmd.Flags().Int("min-price", 0, "최소 가격")
    searchCmd.Flags().Int("max-price", 0, "최대 가격")
    searchCmd.Flags().IntP("limit", "l", 10, "결과 개수 제한")
}

func formatPrice(price int) string {
    if price >= 1000000 {
        return fmt.Sprintf("%.1f만", float64(price)/10000)
    }
    return fmt.Sprintf("%d", price)
}

### Post 커맨드 구현 새로운 재능을 등록하는 명령어도 만들자:

// cmd/post.go
package cmd

import (
    "bufio"
    "fmt"
    "os"
    "strings"
    "github.com/fatih/color"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
    "jaenung-cli/internal/api"
)

var postCmd = &cobra.Command{
    Use:   "post",
    Short: "새로운 재능 등록",
    Long:  `재능넷에 새로운 재능을 등록합니다.`,
    Run: func(cmd *cobra.Command, args []string) {
        interactive, _ := cmd.Flags().GetBool("interactive")
        
        var talent api.Talent
        
        if interactive {
            talent = promptTalentInfo()
        } else {
            title, _ := cmd.Flags().GetString("title")
            description, _ := cmd.Flags().GetString("description")
            category, _ := cmd.Flags().GetString("category")
            price, _ := cmd.Flags().GetInt("price")
            
            if title == "" || description == "" || category == "" {
                color.Red("❌ 필수 정보가 누락되었습니다")
                fmt.Println("--interactive 플래그를 사용하거나 모든 필수 플래그를 지정하세요")
                return
            }
            
            talent = api.Talent{
                Title:       title,
                Description: description,
                Category:    category,
                Price:       price,
            }
        }
        
        // 확인
        fmt.Println("\n📝 등록할 재능 정보:")
        fmt.Printf("제목: %s\n", talent.Title)
        fmt.Printf("카테고리: %s\n", talent.Category)
        fmt.Printf("가격: %d원\n", talent.Price)
        fmt.Printf("설명: %s\n", talent.Description)
        
        fmt.Print("\n등록하시겠습니까? (y/N): ")
        reader := bufio.NewReader(os.Stdin)
        confirm, _ := reader.ReadString('\n')
        confirm = strings.TrimSpace(strings.ToLower(confirm))
        
        if confirm != "y" && confirm != "yes" {
            color.Yellow("⚠️  등록이 취소되었습니다")
            return
        }
        
        // API 클라이언트 생성
        client := api.NewClient(
            viper.GetString("api.base_url"),
            viper.GetString("api.key"),
        )
        
        // 재능 등록
        if err := client.PostTalent(talent); err != nil {
            color.Red("❌ 등록 실패: %v", err)
            return
        }
        
        color.Green("✓ 재능이 성공적으로 등록되었습니다!")
        fmt.Println("재능넷(https://www.jaenung.net)에서 확인하세요.")
    },
}

func init() {
    rootCmd.AddCommand(postCmd)
    
    postCmd.Flags().BoolP("interactive", "i", false, "대화형 모드")
    postCmd.Flags().String("title", "", "재능 제목")
    postCmd.Flags().String("description", "", "재능 설명")
    postCmd.Flags().String("category", "", "카테고리")
    postCmd.Flags().Int("price", 0, "가격")
}

func promptTalentInfo() api.Talent {
    reader := bufio.NewReader(os.Stdin)
    
    fmt.Print("제목: ")
    title, _ := reader.ReadString('\n')
    title = strings.TrimSpace(title)
    
    fmt.Print("카테고리: ")
    category, _ := reader.ReadString('\n')
    category = strings.TrimSpace(category)
    
    fmt.Print("가격 (원): ")
    var price int
    fmt.Scanln(&price)
    reader.ReadString('\n') // 버퍼 비우기
    
    fmt.Print("설명: ")
    description, _ := reader.ReadString('\n')
    description = strings.TrimSpace(description)
    
    return api.Talent{
        Title:       title,
        Description: description,
        Category:    category,
        Price:       price,
    }
}

### 설정 파일

# .jaenung.yaml
api:
  base_url: "https://api.jaenung.net"
  key: "your-api-key-here"

defaults:
  search_limit: 10
  category: ""

output:
  format: "table"  # table, json, yaml
  color: true
  verbose: false

이제 이렇게 사용할 수 있어:

# 재능 검색
jaenung-cli search "프로그래밍" --category "개발" --limit 5

# 대화형 모드로 재능 등록
jaenung-cli post --interactive

# 플래그로 재능 등록
jaenung-cli post \
  --title "Go 언어 과외" \
  --description "Go 언어를 처음부터 알려드립니다" \
  --category "교육" \
  --price 50000

## 🌟 베스트 프랙티스와 팁 CLI 도구를 만들면서 배운 베스트 프랙티스들을 정리해볼게! ### 1. 사용자 친화적인 에러 메시지 에러 메시지는 명확하고 해결 방법을 제시해야 해:

// 나쁜 예
fmt.Println("Error: invalid input")

// 좋은 예
color.Red("❌ 오류: 유효하지 않은 입력입니다")
fmt.Println("\n해결 방법:")
fmt.Println("  1. 파일 경로를 확인하세요")
fmt.Println("  2. 파일 권한을 확인하세요")
fmt.Println("  3. --help 옵션으로 사용법을 확인하세요")

### 2. 진행 상황 표시 오래 걸리는 작업은 반드시 진행 상황을 보여줘:

spinner := spinner.New(spinner.CharSets[14], 100*time.Millisecond)
spinner.Suffix = " 파일 처리 중..."
spinner.Start()

// 작업 수행
processFiles()

spinner.Stop()
color.Green("✓ 완료!")

### 3. 설정의 우선순위 설정 값의 우선순위를 명확히 해: 1. 커맨드 라인 플래그 2. 환경 변수 3. 설정 파일 4. 기본값 ### 4. 도움말 작성 명확하고 예제가 포함된 도움말을 작성해:

var searchCmd = &cobra.Command{
    Use:   "search [키워드]",
    Short: "재능 검색",
    Long: `재능넷에서 키워드로 재능을 검색합니다.

검색 옵션:
  - 카테고리 필터링
  - 가격 범위 지정
  - 결과 개수 제한`,
    Example: `  # 기본 검색
  jaenung-cli search "프로그래밍"

  # 카테고리와 가격 필터
  jaenung-cli search "디자인" --category "그래픽" --max-price 100000

  # 상세 정보 포함
  jaenung-cli search "번역" --verbose`,
    Run: searchRun,
}

### 5. 버전 정보 제공 항상 버전 정보를 제공해:

var (
    version = "dev"
    commit  = "none"
    date    = "unknown"
)

var versionCmd = &cobra.Command{
    Use:   "version",
    Short: "버전 정보 출력",
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Printf("jaenung-cli version %s\n", version)
        fmt.Printf("commit: %s\n", commit)
        fmt.Printf("built at: %s\n", date)
    },
}

빌드 시 버전 정보를 주입:

go build -ldflags="-X main.version=1.0.0 -X main.commit=$(git rev-parse HEAD) -X main.date=$(date -u +%Y-%m-%dT%H:%M:%SZ)"

### 6. 로깅 레벨 다양한 로깅 레벨을 지원해:

import "github.com/sirupsen/logrus"

var log = logrus.New()

func init() {
    if viper.GetBool("debug") {
        log.SetLevel(logrus.DebugLevel)
    } else if viper.GetBool("verbose") {
        log.SetLevel(logrus.InfoLevel)
    } else {
        log.SetLevel(logrus.WarnLevel)
    }
}

### 7. 안전한 종료 시그널을 처리해서 안전하게 종료:

import (
    "context"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    
    // 시그널 처리
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
    
    go func() {
        <-sigChan
        fmt.Println("\n종료 중...")
        cancel()
    }()
    
    // 메인 로직 실행
    if err := run(ctx); err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
}

## 🔮 더 나아가기 CLI 도구 개발의 기본을 마스터했다면, 이제 더 고급 주제들을 탐험해볼 차례야! ### TUI (Text User Interface) 만들기 터미널에서도 GUI처럼 인터랙티브한 인터페이스를 만들 수 있어. bubbletea 라이브러리를 사용하면 돼:

go get github.com/charmbracelet/bubbletea
go get github.com/charmbracelet/lipgloss

간단한 메뉴 예제:

package main

import (
    "fmt"
    "os"
    tea "github.com/charmbracelet/bubbletea"
    "github.com/charmbracelet/lipgloss"
)

type model struct {
    choices  []string
    cursor   int
    selected map[int]struct{}
}

func initialModel() model {
    return model{
        choices: []string{"검색", "등록", "프로필", "종료"},
        selected: make(map[int]struct{}),
    }
}

func (m model) Init() tea.Cmd {
    return nil
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch msg.String() {
        case "ctrl+c", "q":
            return m, tea.Quit
        case "up", "k":
            if m.cursor > 0 {
                m.cursor--
            }
        case "down", "j":
            if m.cursor < len(m.choices)-1 {
                m.cursor++
            }
        case "enter", " ":
            _, ok := m.selected[m.cursor]
            if ok {
                delete(m.selected, m.cursor)
            } else {
                m.selected[m.cursor] = struct{}{}
            }
        }
    }
    return m, nil
}

func (m model) View() string {
    s := "재능넷 CLI - 메뉴를 선택하세요:\n\n"
    
    for i, choice := range m.choices {
        cursor := " "
        if m.cursor == i {
            cursor = ">"
        }
        
        checked := " "
        if _, ok := m.selected[i]; ok {
            checked = "x"
        }
        
        s += fmt.Sprintf("%s [%s] %s\n", cursor, checked, choice)
    }
    
    s += "\n(↑/↓: 이동, Space: 선택, Enter: 실행, q: 종료)\n"
    
    return s
}

func main() {
    p := tea.NewProgram(initialModel())
    if err := p.Start(); err != nil {
        fmt.Printf("Error: %v", err)
        os.Exit(1)
    }
}

### 플러그인 시스템 확장 가능한 CLI 도구를 만들고 싶다면 플러그인 시스템을 구현할 수 있어:

// plugin/plugin.go
package plugin

import "plugin"

type Plugin interface {
    Name() string
    Execute(args []string) error
}

func LoadPlugin(path string) (Plugin, error) {
    p, err := plugin.Open(path)
    if err != nil {
        return nil, err
    }
    
    symPlugin, err := p.Lookup("Plugin")
    if err != nil {
        return nil, err
    }
    
    var plug Plugin
    plug, ok := symPlugin.(Plugin)
    if !ok {
        return nil, fmt.Errorf("unexpected type from module symbol")
    }
    
    return plug, nil
}

### 데이터베이스 통합 로컬 데이터를 저장해야 한다면 SQLite를 사용할 수 있어:

go get github.com/mattn/go-sqlite3

package db

import (
    "database/sql"
    _ "github.com/mattn/go-sqlite3"
)

type DB struct {
    conn *sql.DB
}

func New(path string) (*DB, error) {
    conn, err := sql.Open("sqlite3", path)
    if err != nil {
        return nil, err
    }
    
    // 테이블 생성
    _, err = conn.Exec(`
        CREATE TABLE IF NOT EXISTS history (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            command TEXT NOT NULL,
            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    `)
    if err != nil {
        return nil, err
    }
    
    return &DB{conn: conn}, nil
}

func (db *DB) SaveCommand(command string) error {
    _, err := db.conn.Exec("INSERT INTO history (command) VALUES (?)", command)
    return err
}

func (db *DB) GetHistory(limit int) ([]string, error) {
    rows, err := db.conn.Query(
        "SELECT command FROM history ORDER BY timestamp DESC LIMIT ?", 
        limit,
    )
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var history []string
    for rows.Next() {
        var cmd string
        if err := rows.Scan(&cmd); err != nil {
            return nil, err
        }
        history = append(history, cmd)
    }
    
    return history, nil
}

### 웹 서버 모드 CLI 도구에 웹 인터페이스를 추가할 수도 있어:

var serveCmd = &cobra.Command{
    Use:   "serve",
    Short: "웹 서버 모드로 실행",
    Run: func(cmd *cobra.Command, args []string) {
        port, _ := cmd.Flags().GetInt("port")
        
        http.HandleFunc("/api/search", handleSearch)
        http.HandleFunc("/api/post", handlePost)
        
        addr := fmt.Sprintf(":%d", port)
        color.Green("🌐 웹 서버 시작: http://localhost%s", addr)
        
        if err := http.ListenAndServe(addr, nil); err != nil {
            color.Red("❌ 서버 시작 실패: %v", err)
        }
    },
}

func init() {
    rootCmd.AddCommand(serveCmd)
    serveCmd.Flags().IntP("port", "p", 8080, "포트 번호")
}

## 🎬 마무리하며 와! 여기까지 정말 긴 여정이었어. Go언어로 CLI 애플리케이션을 만드는 방법을 처음부터 끝까지 살펴봤어. Cobra와 Viper를 사용하면 프로페셔널한 명령행 도구를 정말 쉽게 만들 수 있다는 걸 알았을 거야. 🎉 핵심 내용을 다시 정리하면: **🔹 Cobra**는 명령어 구조와 플래그 관리를 담당해. 서브커맨드를 쉽게 만들고, 자동 완성과 도움말을 자동으로 생성해줘. **🔹 Viper**는 설정 관리의 모든 것을 해결해줘. 설정 파일, 환경 변수, 플래그를 통합해서 관리하고, 우선순위도 자동으로 처리해. **🔹 Go언어**는 CLI 도구를 만들기에 완벽한 언어야. 단일 바이너리 배포, 크로스 컴파일, 빠른 성능, 동시성 처리까지 모든 게 갖춰져 있어. 이제 여러분도 자신만의 멋진 CLI 도구를 만들 수 있을 거야! 파일 관리 도구든, API 클라이언트든, 자동화 스크립트든 뭐든지 만들 수 있어. 재능넷 같은 플랫폼에서 여러분의 개발 재능을 공유할 수도 있고 말이야! 😊 CLI 도구 개발은 정말 재미있고 보람찬 작업이야. 한 번 만들어두면 매일 사용하면서 시간을 절약할 수 있거든. 그리고 오픈소스로 공개하면 다른 개발자들에게도 도움이 되지! 자, 이제 여러분 차례야. 터미널을 열고, 코드 에디터를 켜고, 멋진 CLI 도구를 만들어보자! 화이팅! 🚀