Git Hooks

1
2
3

# 예시: pre-commit 훅
#!/bin/sh
npm run lint  # 커밋 전 린트 실행

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#!/bin/sh
# .git/hooks/pre-commit

echo "🔍 Running lint check before commit..."
npx eslint . --ext .js,.jsx,.ts,.tsx

if [ $? -ne 0 ]; then
  echo "❌ Lint errors detected. Commit aborted."
  exit 1
fi

echo "✅ Lint passed. Proceeding with commit."

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: detect-private-key
        stages: [pre-push]  # push 시에만 실행
  - repo: https://github.com/pre-commit/pre-commit-hooks
	rev: v4.5.0
	hooks:
	  - id: trailing-whitespace  # 줄 끝 공백 제거
	  - id: end-of-file-fixer    # 파일 끝 개행 문자 추가
	  - id: check-yaml           # YAML 문법 검사

  - repo: https://github.com/psf/black
	rev: 24.1.1
	hooks:
	  - id: black
		language_version: python3.11
		args: ["--line-length=88"]  # 최대 줄 길이 설정

  - repo: https://github.com/pycqa/isort
	rev: 5.13.2
	hooks:
	  - id: isort  # import 정렬

  - repo: https://github.com/pycqa/flake8
	rev: 7.0.0
	hooks:
	  - id: flake8  # 코드 스타일 검사

1
2
3

pip install pre-commit
pre-commit install  # Git hook 설치
pre-commit run --all-files  # 전체 파일에 대해 hook 실행

1
2
3
4
5
6
7
8

# 1. Husky 설치
npm install husky --save-dev

# 2. Husky 초기화(필수)
npx husky install

# 3. (선택) install 후 자동 실행하게 하려면 package.json에 추가:
npm set-script prepare "husky install"

1
2
3
4
5
6

프로젝트/
 ├─ .husky/
 │   ├─ pre-commit
 │   └─ pre-push
 ├─ package.json
 └─ …

1
2
3
4
5
6
7
8

pre-commit:
  parallel: true  # 병렬 실행
  commands:
    lint:
      glob: "*.js"
      run: npm run lint
    test:
      run: npm test

1
2

npm install lefthook --save-dev
npx lefthook install

1
2
3
4
5

.
├── .pre-commit-config.yaml
└── .github
    └── workflows
        └── pre-commit.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.5.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
  - repo: https://github.com/psf/black
    rev: 24.3.0
    hooks:
      - id: black

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

name: pre-commit checks

on:
  pull_request:
  push:
    branches: [main, develop]

jobs:
  lint-and-format:
    name: Run pre-commit hooks
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install pre-commit

      - name: Run pre-commit hooks
        run: pre-commit run --all-files

1
2
3
4
5
6

[개발자 로컬]
pre-commit → 린트/테스트 → 실패 시 커밋 차단
           ↘ 성공 시 커밋 완료 → 원격 저장소 푸시

[서버]
pre-receive → 코드 검증 → 승인 시 배포 파이프라인 실행

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# .pre-commit-config.yaml

repos:
  # 1. Black: 코드 포맷 자동화 (PEP8 기준으로 포맷팅)
  - repo: https://github.com/psf/black
    rev: 24.3.0      # 사용할 Black의 버전. 최신 버전 참고
    hooks:
      - id: black
        language_version: python3.10  # 프로젝트에 맞는 파이썬 버전 선언

  # 2. Flake8: 코드 스타일&에러 정적분석
  - repo: https://github.com/pycqa/flake8
    rev: 7.0.0        # 사용할 Flake8의 버전
    hooks:
      - id: flake8
        additional_dependencies: [flake8-bugbear] # flake8 보완 플러그인 추가

  # 3. isort: import문 정렬
  - repo: https://github.com/pre-commit/mirrors-isort
    rev: v5.13.2
    hooks:
      - id: isort

  # 4. debug-statements: print, pdb 등 디버깅 코드 커밋 방지
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: debug-statements

  # 5. detect-secrets: 시크릿(비밀번호, 토큰 등) 커밋 방지
  - repo: https://github.com/Yelp/detect-secrets
    rev: v1.4.0
    hooks:
      - id: detect-secrets
        # 추가 설정은 필요에 따라 detect-secrets 설정 파일 이용

  # 6. check-yaml: yaml파일 문법 오류 검증
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: check-yaml

  # 7. end-of-file-fixer: 파일 끝에 빈 줄 삽입 보장
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: end-of-file-fixer

1
2
3
4
5
6
7
8
9

repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
    rev: v0.4.4  # 사용하려는 Ruff 버전의 최신 태그로 맞추세요
    hooks:
      - id: ruff
        args: ["."]  # 현재 디렉토리 전체에 적용, 필요시 경로/옵션 조정
        additional_dependencies: []   # 플러그인 쓸 땐 여기에 패키지 추가
      - id: ruff-format
        args: ["."]  # 코드 포매팅도 동시에 적용하려면 추가

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#!/usr/bin/env python3
# .git/hooks/pre-commit (chmod +x 필요)

import subprocess
import sys

def main():
    """커밋 전에 코드 품질 검사를 수행합니다."""
    print("코드 품질 검사를 시작합니다...")
    
    # 변경된 Python 파일 찾기
    result = subprocess.run(
        ['git', 'diff', '--cached', '--name-only', '--diff-filter=ACM', '*.py'],
        capture_output=True, text=True
    )
    
    if not result.stdout:
        print("변경된 Python 파일이 없습니다.")
        return 0
    
    files = result.stdout.strip().split('\n')
    print(f"{len(files)}개의 Python 파일이 변경되었습니다.")
    
    # Black으로 코드 포맷팅 검사
    print("코드 포맷팅 검사 중...")
    format_check = subprocess.run(['black', '--check'] + files, capture_output=True)
    
    if format_check.returncode != 0:
        print("코드 포맷팅 문제가 발견되었습니다. 자동으로 수정합니다...")
        subprocess.run(['black'] + files)
        print("코드가 재포맷되었습니다. 변경사항을 다시 스테이징해주세요.")
        return 1
    
    # Flake8으로 린팅
    print("린팅 검사 중...")
    lint_result = subprocess.run(['flake8'] + files, capture_output=True, text=True)
    
    if lint_result.returncode != 0:
        print("린팅 문제가 발견되었습니다:")
        print(lint_result.stdout)
        return 1
    
    # 테스트 실행
    print("단위 테스트 실행 중...")
    test_result = subprocess.run(['pytest'], capture_output=True, text=True)
    
    if test_result.returncode != 0:
        print("테스트 실패:")
        print(test_result.stdout)
        return 1
    
    print("모든 검사가 통과되었습니다!")
    return 0

if __name__ == "__main__":
    sys.exit(main())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# .pre-commit-config.yaml
repos:
-   repo: https://github.com/commitizen-tools/commitizen
    rev: v2.42.1
    hooks:
    -   id: commitizen
        stages: [commit-msg]

-   repo: local
    hooks:
    -   id: version-bump
        name: version-bump
        entry: python scripts/version_bump.py
        language: python
        pass_filenames: false
        stages: [post-commit]
        always_run: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#!/usr/bin/env python3
# scripts/validate_commit_message.py

import re
import sys

def validate_commit_message(commit_msg_file):
    """
    커밋 메시지가 Conventional Commits 형식을 따르는지 검증합니다.
    형식: <type>(<scope>): <subject>
    
    예: feat(user): 사용자 인증 기능 추가
    """
    with open(commit_msg_file, 'r') as f:
        commit_msg = f.read().strip()
    
    # Conventional Commits 패턴
    pattern = r'^(feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert)(\([a-z0-9-]+\))?: .+'
    
    if not re.match(pattern, commit_msg):
        print("오류: 커밋 메시지가 Conventional Commits 형식에 맞지 않습니다.")
        print("예시: feat(user): 사용자 인증 기능 추가")
        print("유효한 유형: feat, fix, docs, style, refactor, perf, test, chore, ci, build, revert")
        return 1
    
    return 0

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("커밋 메시지 파일 경로를 지정해주세요.")
        sys.exit(1)
    
    sys.exit(validate_commit_message(sys.argv[1]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#!/usr/bin/env python3
# scripts/version_bump.py

import re
import subprocess
from pathlib import Path

def get_last_commit_type():
    """마지막 커밋의 유형을 가져옵니다."""
    result = subprocess.run(
        ['git', 'log', '-1', '--pretty=%B'],
        capture_output=True, text=True
    )
    commit_msg = result.stdout.strip()
    
    # Conventional Commits 패턴에서 유형 추출
    match = re.match(r'^(feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert)', commit_msg)
    if match:
        return match.group(1)
    return None

def update_version():
    """버전 파일을 업데이트합니다."""
    version_file = Path('VERSION')
    if not version_file.exists():
        version_file.write_text('0.1.0')
        print("버전 파일이 생성되었습니다: 0.1.0")
        return
    
    # 현재 버전 읽기
    current_version = version_file.read_text().strip()
    major, minor, patch = map(int, current_version.split('.'))
    
    # 커밋 유형에 따라 버전 업데이트
    commit_type = get_last_commit_type()
    if commit_type == 'feat':
        minor += 1
        patch = 0
    elif commit_type in ('fix', 'perf'):
        patch += 1
    else:
        # 다른 유형은 버전 변경 없음
        return
    
    # 새 버전 쓰기
    new_version = f"{major}.{minor}.{patch}"
    version_file.write_text(new_version)
    print(f"버전이 업데이트되었습니다: {current_version} -> {new_version}")
    
    # 버전 변경사항 커밋
    subprocess.run(['git', 'add', 'VERSION'])
    subprocess.run(['git', 'commit', '--amend', '--no-edit'])
    print("버전 변경사항이 커밋에 추가되었습니다.")

if __name__ == "__main__":
    update_version()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# .pre-commit-config.yaml
repos:
-   repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
    -   id: detect-private-key
    -   id: detect-aws-credentials

-   repo: https://github.com/Yelp/detect-secrets
    rev: v1.4.0
    hooks:
    -   id: detect-secrets

-   repo: https://github.com/PyCQA/bandit
    rev: 1.7.5
    hooks:
    -   id: bandit
        args: ['-r', '.']

-   repo: local
    hooks:
    -   id: dependency-check
        name: dependency-check
        entry: python scripts/check_dependencies.py
        language: python
        pass_filenames: false
        always_run: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#!/usr/bin/env python3
# scripts/check_dependencies.py

import json
import subprocess
import sys
from pathlib import Path

def check_dependencies():
    """프로젝트의 의존성 패키지에서 보안 취약점을 검사합니다."""
    print("의존성 보안 취약점 검사 중...")
    
    # requirements.txt 존재 확인
    req_file = Path('requirements.txt')
    if not req_file.exists():
        print("requirements.txt 파일이 존재하지 않습니다.")
        return 0
    
    # safety 패키지를 사용하여 의존성 취약점 검사
    try:
        result = subprocess.run(
            ['safety', 'check', '-r', 'requirements.txt', '--json'],
            capture_output=True, text=True
        )
        
        # 결과 파싱
        if result.returncode != 0:
            try:
                vulnerabilities = json.loads(result.stdout)
                print(f"{len(vulnerabilities)} 개의 취약점이 발견되었습니다:")
                
                for vuln in vulnerabilities:
                    package = vuln.get('package', 'Unknown')
                    vuln_id = vuln.get('id', 'Unknown')
                    spec = vuln.get('spec', 'Unknown')
                    cve = vuln.get('cve', 'N/A')
                    
                    print(f"  - {package} ({spec}): {vuln_id} (CVE: {cve})")
                    print(f"    대응 방안: {vuln.get('advisory', 'N/A')}")
                
                print("\n심각한 보안 취약점이 발견되었습니다. 의존성을 업데이트하세요.")
                return 1
            except json.JSONDecodeError:
                print("취약점 결과를 파싱할 수 없습니다.")
                print(result.stdout)
                return 1
        
        print("알려진 보안 취약점이 없습니다.")
        return 0
        
    except FileNotFoundError:
        print("safety 패키지가 설치되어 있지 않습니다. 설치하려면:")
        print("pip install safety")
        return 1

if __name__ == "__main__":
    sys.exit(check_dependencies())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# .pre-commit-config.yaml
repos:
-   repo: local
    hooks:
    -   id: validate-migrations
        name: validate-migrations
        entry: python scripts/validate_migrations.py
        language: python
        files: 'migrations/.*\.py$'
        pass_filenames: true

    -   id: generate-db-docs
        name: generate-db-docs
        entry: python scripts/generate_db_docs.py
        language: python
        files: 'models/.*\.py$'
        pass_filenames: false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#!/usr/bin/env python3
# scripts/validate_migrations.py

import os
import re
import sys
from pathlib import Path

def validate_migrations(migration_files):
    """마이그레이션 파일의 형식과 내용을 검증합니다."""
    if not migration_files:
        print("검증할 마이그레이션 파일이 없습니다.")
        return 0
    
    errors = []
    
    for file_path in migration_files:
        path = Path(file_path)
        if not path.exists():
            errors.append(f"파일을 찾을 수 없습니다: {file_path}")
            continue
        
        # 파일 이름 검증
        filename = path.name
        if not re.match(r'^\d{4}_[a-z0-9_]+\.py$', filename):
            errors.append(f"마이그레이션 파일 이름이 규칙을 따르지 않습니다: {filename}")
        
        # 파일 내용 검증
        with open(path, 'r') as f:
            content = f.read()
            
            # 설명 문서 확인
            if not re.search(r'""".*?"""', content, re.DOTALL):
                errors.append(f"마이그레이션 설명 문서가 없습니다: {filename}")
            
            # upgrade 및 downgrade 함수 확인
            if not re.search(r'def upgrade\(\):', content):
                errors.append(f"upgrade() 함수가 없습니다: {filename}")
            
            if not re.search(r'def downgrade\(\):', content):
                errors.append(f"downgrade() 함수가 없습니다: {filename}")
    
    if errors:
        for error in errors:
            print(f"오류: {error}")
        return 1
    
    print("모든 마이그레이션 파일이 유효합니다.")
    return 0

if __name__ == "__main__":
    sys.exit(validate_migrations(sys.argv[1:]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

#!/usr/bin/env python3
# scripts/generate_db_docs.py

import importlib
import inspect
import os
import sys
from pathlib import Path

def generate_db_docs():
    """SQLAlchemy 모델을 기반으로 데이터베이스 스키마 문서를 생성합니다."""
    print("데이터베이스 스키마 문서 생성 중...")
    
    models_dir = Path('models')
    if not models_dir.exists() or not models_dir.is_dir():
        print("models 디렉토리를 찾을 수 없습니다.")
        return 1
    
    # 모델 모듈 동적 임포트
    sys.path.insert(0, str(Path.cwd()))
    model_classes = []
    
    for py_file in models_dir.glob('*.py'):
        if py_file.name == '__init__.py':
            continue
        
        module_name = f"models.{py_file.stem}"
        try:
            module = importlib.import_module(module_name)
            
            # SQLAlchemy 모델 클래스 찾기
            for name, obj in inspect.getmembers(module):
                if inspect.isclass(obj) and hasattr(obj, '__tablename__'):
                    model_classes.append(obj)
        except ImportError as e:
            print(f"모듈 임포트 오류: {module_name} - {e}")
    
    if not model_classes:
        print("SQLAlchemy 모델 클래스를 찾을 수 없습니다.")
        return 1
    
    # 마크다운 문서 생성
    docs_dir = Path('docs')
    docs_dir.mkdir(exist_ok=True)
    
    with open(docs_dir / 'database_schema.md', 'w') as f:
        f.write("# 데이터베이스 스키마 문서\n\n")
        
        for model in sorted(model_classes, key=lambda m: m.__tablename__):
            f.write(f"## {model.__name__}\n\n")
            f.write(f"**테이블 이름:** `{model.__tablename__}`\n\n")
            
            if model.__doc__:
                f.write(f"{model.__doc__.strip()}\n\n")
            
            f.write("### 컬럼\n\n")
            f.write("| 이름 | 타입 | 제약 조건 | 설명 |\n")
            f.write("|------|------|-----------|------|\n")
            
            for column_name, column in model.__table__.columns.items():
                constraints = []
                if column.primary_key:
                    constraints.append("기본 키")
                if not column.nullable:
                    constraints.append("NOT NULL")
                if column.unique:
                    constraints.append("고유")
                if column.foreign_keys:
                    for fk in column.foreign_keys:
                        constraints.append(f"외래 키 ({fk.target_fullname})")
                
                constraints_str = ", ".join(constraints)
                column_type = str(column.type)
                column_doc = getattr(column, 'doc', '')
                
                f.write(f"| {column_name} | {column_type} | {constraints_str} | {column_doc} |\n")
            
            f.write("\n\n")
    
    print(f"데이터베이스 스키마 문서가 생성되었습니다: {docs_dir}/database_schema.md")
    
    # 문서 변경사항 스테이징
    os.system(f"git add {docs_dir}/database_schema.md")
    print("문서 변경사항이 스테이징되었습니다.")
    
    return 0

if __name__ == "__main__":
    sys.exit(generate_db_docs())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# .pre-commit-config.yaml
repos:
-   repo: local
    hooks:
    -   id: pre-push-build-check
        name: pre-push-build-check
        entry: python scripts/pre_push_build_check.py
        language: python
        pass_filenames: false
        stages: [push]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#!/usr/bin/env python3
# scripts/pre_push_build_check.py

import os
import subprocess
import sys
import time

def pre_push_build_check():
    """푸시 전에 빌드 검증을 수행합니다."""
    print("푸시 전 빌드 검증을 시작합니다...")
    
    # 브랜치 확인
    result = subprocess.run(
        ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
        capture_output=True, text=True
    )
    current_branch = result.stdout.strip()
    
    # main/master 브랜치인 경우 추가 검증
    if current_branch in ('main', 'master'):
        print(f"{current_branch} 브랜치로 푸시합니다. 추가 검증을 수행합니다...")
        
        # 모든 테스트 실행
        print("전체 테스트 실행 중...")
        test_result = subprocess.run(['pytest', '--cov=app'], capture_output=True, text=True)
        
        if test_result.returncode != 0:
            print("테스트 실패:")
            print(test_result.stdout)
            return 1
        
        # 커버리지 검사
        coverage_output = test_result.stdout
        coverage_match = re.search(r'TOTAL\s+\d+\s+\d+\s+(\d+)%', coverage_output)
        
        if coverage_match:
            coverage = int(coverage_match.group(1))
            if coverage < 80:
                print(f"코드 커버리지가 기준보다 낮습니다: {coverage}% (기준: 80%)")
                return 1
            print(f"코드 커버리지: {coverage}%")
        
        # 빌드 검증
        print("빌드 검증 중...")
        if os.path.exists('setup.py'):
            build_result = subprocess.run(['python', 'setup.py', 'sdist'], capture_output=True, text=True)
            
            if build_result.returncode != 0:
                print("빌드 실패:")
                print(build_result.stderr)
                return 1
    
    # 일반적인 검증
    else:
        print(f"{current_branch} 브랜치로 푸시합니다. 기본 검증을 수행합니다...")
        
        # 필수 테스트 실행
        print("기본 테스트 실행 중...")
        test_result = subprocess.run(['pytest'], capture_output=True, text=True)
        
        if test_result.returncode != 0:
            print("테스트 실패:")
            print(test_result.stdout)
            return 1
    
    print("모든 검증이 통과되었습니다. 푸시를 진행합니다...")
    return 0

if __name__ == "__main__":
    sys.exit(pre_push_build_check())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#!/usr/bin/env python3
# .git/hooks/post-push (chmod +x 필요)

import os
import subprocess
import sys
import time
import requests

def trigger_ci_pipeline():
    """Git push 후 CI 파이프라인을 트리거합니다."""
    print("CI/CD 파이프라인 트리거 중...")
    
    # 현재 브랜치와 커밋 정보 가져오기
    branch = subprocess.run(
        ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
        capture_output=True, text=True
    ).stdout.strip()
    
    commit = subprocess.run(
        ['git', 'rev-parse', 'HEAD'],
        capture_output=True, text=True
    ).stdout.strip()
    
    # Jenkins CI 파이프라인 트리거 예시
    jenkins_url = os.environ.get('JENKINS_URL', 'http://jenkins.example.com')
    jenkins_token = os.environ.get('JENKINS_TOKEN', '')
    
    if not jenkins_token:
        print("경고: JENKINS_TOKEN 환경 변수가 설정되지 않았습니다.")
        return 1
    
    pipeline_url = f"{jenkins_url}/job/my-project/buildWithParameters"
    
    try:
        response = requests.post(
            pipeline_url,
            params={
                'token': jenkins_token,
                'BRANCH': branch,
                'COMMIT': commit
            },
            timeout=10
        )
        
        if response.status_code == 201:
            print(f"CI 파이프라인이 트리거되었습니다. 브랜치: {branch}, 커밋: {commit[:8]}")
            
            # 빌드 상태 모니터링 (선택 사항)
            print("빌드 상태 확인 중...")
            time.sleep(5)  # 빌드 시작 대기
            
            for _ in range(5):  # 최대 5번 확인
                status_response = requests.get(
                    f"{jenkins_url}/job/my-project/lastBuild/api/json",
                    params={'token': jenkins_token},
                    timeout=10
                )
                
                if status_response.status_code == 200:
                    build_data = status_response.json()
                    build_number = build_data.get('number', 'Unknown')
                    build_result = build_data.get('result')
                    
                    if build_result:
                        print(f"빌드 #{build_number} 결과: {build_result}")
                        print(f"빌드 URL: {build_data.get('url', jenkins_url)}")
                        break
                    else:
                        print(f"빌드 #{build_number} 실행 중...")
                
                time.sleep(10)
            
            return 0
        else:
            print(f"CI 파이프라인 트리거 실패: {response.status_code} - {response.text}")
            return 1
    
    except Exception as e:
        print(f"CI 파이프라인 트리거 중 오류 발생: {e}")
        return 1

if __name__ == "__main__":
    sys.exit(trigger_ci_pipeline())