// 1. 프로젝트 Fork & Clone
git clone https://github.com/your-username/awesome-go-cli.git
cd awesome-go-cli

// 2. 새로운 브랜치 생성
git checkout -b feature/add-color-output

// 3. 의존성 설치
go mod download

// 4. 테스트 실행해서 현재 상태 확인
go test ./...

// color.go - 새로운 파일 생성
package main

import "fmt"

// ANSI 색상 코드
const (
    ColorReset  = "\033[0m"
    ColorRed    = "\033[31m"
    ColorGreen  = "\033[32m"
    ColorYellow = "\033[33m"
    ColorBlue   = "\033[34m"
)

// Colorize는 텍스트에 색상을 적용합니다
func Colorize(text, color string) string {
    return color + text + ColorReset
}

// PrintSuccess는 성공 메시지를 녹색으로 출력합니다
func PrintSuccess(message string) {
    fmt.Println(Colorize("✓ "+message, ColorGreen))
}

// PrintError는 에러 메시지를 빨간색으로 출력합니다
func PrintError(message string) {
    fmt.Println(Colorize("✗ "+message, ColorRed))
}

// color_test.go
package main

import (
    "testing"
)

func TestColorize(t *testing.T) {
    tests := []struct {
        name     string
        text     string
        color    string
        expected string
    }{
        {
            name:     "Red text",
            text:     "Error",
            color:    ColorRed,
            expected: "\033[31mError\033[0m",
        },
        {
            name:     "Green text",
            text:     "Success",
            color:    ColorGreen,
            expected: "\033[32mSuccess\033[0m",
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Colorize(tt.text, tt.color)
            if result != tt.expected {
                t.Errorf("got %q, want %q", result, tt.expected)
            }
        })
    }
}

## 변경 사항
CLI 메시지에 ANSI 색상 코드를 사용한 컬러 출력 기능을 추가했습니다.

## 동기
사용자가 성공/실패 메시지를 더 쉽게 구분할 수 있도록 하기 위함입니다.
특히 긴 로그에서 중요한 정보를 빠르게 찾을 수 있습니다.

## 변경 내용
- `color.go`: 색상 관련 유틸리티 함수 추가
- `color_test.go`: 색상 함수에 대한 단위 테스트 추가
- `main.go`: 기존 출력 함수를 색상 출력으로 변경

## 테스트
- 모든 기존 테스트 통과 확인
- 새로운 색상 함수에 대한 테스트 추가
- 다양한 터미널 환경에서 수동 테스트 완료

## 스크린샷
[Before/After 스크린샷 첨부]

Closes #123

// 리뷰어 코멘트:
// "Colorize 함수가 매번 문자열을 연결하는데,
// 성능을 위해 strings.Builder를 사용하는 게 어떨까요?"

// 수정 전
func Colorize(text, color string) string {
    return color + text + ColorReset
}

// 수정 후
func Colorize(text, color string) string {
    var builder strings.Builder
    builder.WriteString(color)
    builder.WriteString(text)
    builder.WriteString(ColorReset)
    return builder.String()
}

// 원본 저장소를 upstream으로 추가
git remote add upstream https://github.com/original/repo.git

// upstream의 최신 변경사항 가져오기
git fetch upstream

// 내 브랜치를 upstream/main과 동기화
git rebase upstream/main

// 커밋 메시지 수정
git commit --amend

// 여러 커밋을 하나로 합치기 (interactive rebase)
git rebase -i HEAD~3

// 특정 파일의 변경사항만 스테이징
git add -p filename.go

// 코드 포맷팅 (저장할 때마다 자동으로 실행되게 설정해)
go fmt ./...

// 코드 정적 분석
go vet ./...

// 테스트 실행
go test ./...

// 테스트 커버리지 확인
go test -cover ./...

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

// 모듈 정리 (사용하지 않는 의존성 제거)
go mod tidy

// 의존성 검증
go mod verify

// golangci-lint 설치
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

// 린팅 실행
golangci-lint run

// 자동 수정 가능한 문제 수정
golangci-lint run --fix

// Delve 설치
go install github.com/go-delve/delve/cmd/dlv@latest

// 디버깅 시작
dlv debug main.go

// 브레이크포인트 설정
(dlv) break main.main

// 실행
(dlv) continue

// 변수 확인
(dlv) print variableName

// 스택 트레이스
(dlv) stack

// logger.go
package logger

import (
    "fmt"
    "io"
    "os"
    "time"
)

// Level은 로그 레벨을 나타냅니다
type Level int

const (
    DEBUG Level = iota
    INFO
    WARN
    ERROR
)

// Logger는 로깅 기능을 제공합니다
type Logger struct {
    level  Level
    output io.Writer
}

// New는 새로운 Logger를 생성합니다
func New(level Level, output io.Writer) *Logger {
    if output == nil {
        output = os.Stdout
    }
    return &Logger{
        level:  level,
        output: output,
    }
}

// log는 내부 로깅 함수입니다
func (l *Logger) log(level Level, format string, args ...interface{}) {
    if level < l.level {
        return
    }
    
    timestamp := time.Now().Format("2006-01-02 15:04:05")
    levelStr := [...]string{"DEBUG", "INFO", "WARN", "ERROR"}[level]
    message := fmt.Sprintf(format, args...)
    
    fmt.Fprintf(l.output, "[%s] %s: %s\n", timestamp, levelStr, message)
}

// Debug는 디버그 레벨 로그를 출력합니다
func (l *Logger) Debug(format string, args ...interface{}) {
    l.log(DEBUG, format, args...)
}

// Info는 정보 레벨 로그를 출력합니다
func (l *Logger) Info(format string, args ...interface{}) {
    l.log(INFO, format, args...)
}

// Warn은 경고 레벨 로그를 출력합니다
func (l *Logger) Warn(format string, args ...interface{}) {
    l.log(WARN, format, args...)
}

// Error는 에러 레벨 로그를 출력합니다
func (l *Logger) Error(format string, args ...interface{}) {
    l.log(ERROR, format, args...)
}

// logger_test.go
package logger

import (
    "bytes"
    "strings"
    "testing"
)

func TestLogger(t *testing.T) {
    var buf bytes.Buffer
    log := New(INFO, &buf)
    
    log.Debug("This should not appear")
    log.Info("This is info")
    log.Warn("This is warning")
    log.Error("This is error")
    
    output := buf.String()
    
    if strings.Contains(output, "DEBUG") {
        t.Error("Debug message should not appear")
    }
    
    if !strings.Contains(output, "INFO") {
        t.Error("Info message should appear")
    }
    
    if !strings.Contains(output, "WARN") {
        t.Error("Warn message should appear")
    }
    
    if !strings.Contains(output, "ERROR") {
        t.Error("Error message should appear")
    }
}

func BenchmarkLogger(b *testing.B) {
    var buf bytes.Buffer
    log := New(INFO, &buf)
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        log.Info("Benchmark message %d", i)
    }
}

// 좋은 예: 명확한 에러 처리
func ReadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("failed to read config file %s: %w", path, err)
    }
    
    var config Config
    if err := json.Unmarshal(data, &config); err != nil {
        return nil, fmt.Errorf("failed to parse config: %w", err)
    }
    
    if err := config.Validate(); err != nil {
        return nil, fmt.Errorf("invalid config: %w", err)
    }
    
    return &config, nil
}

// 나쁜 예: 에러 무시
func ReadConfig(path string) *Config {
    data, _ := os.ReadFile(path)
    var config Config
    json.Unmarshal(data, &config)
    return &config
}

// 특정 커밋만 가져오기 (cherry-pick)
git cherry-pick abc123

// 여러 커밋을 하나로 합치기
git rebase -i HEAD~3

// 특정 파일의 변경사항만 되돌리기
git checkout HEAD~1 -- filename.go

// 작업 중인 변경사항 임시 저장
git stash save "작업 중인 기능"

// stash 목록 보기
git stash list

// stash 적용하기
git stash pop

// 특정 커밋의 변경사항 보기
git show abc123

// 파일의 변경 이력 보기
git log -p filename.go

// 누가 각 줄을 수정했는지 보기
git blame filename.go

// 브랜치 간 차이 보기
git diff main..feature-branch

// 충돌 해결 도구 사용
git mergetool