https://docs.anthropic.com/ko/docs/claude-code/overview
GitHub 커밋 로그를 분석하여 개발 추정 시간을 산출하는 스크립트를 작성해드리겠습니다.
OpenAI API를 연동하여 커밋 내용을 요약하는 기능도 포함하겠습니다.
GitHub 커밋 로그 개발시간 분석 스크립트
#!/usr/bin/env python3
"""
GitHub 커밋 로그 분석 및 개발 시간 추정 스크립트
OpenAI API를 사용하여 커밋 메시지 요약 기능 포함
"""
import subprocess
import json
import re
from datetime import datetime, timedelta
from collections import defaultdict
from typing import List, Dict, Tuple
import pandas as pd
import argparse
import os
from openai import OpenAI
class CommitAnalyzer:
def __init__(self, openai_api_key: str = None):
"""
커밋 분석기 초기화
Args:
openai_api_key: OpenAI API 키 (환경변수 OPENAI_API_KEY에서 가져올 수도 있음)
"""
self.openai_client = None
if openai_api_key or os.getenv('OPENAI_API_KEY'):
self.openai_client = OpenAI(api_key=openai_api_key or os.getenv('OPENAI_API_KEY'))
# 커밋 유형별 개발 시간 추정 (분 단위)
self.time_estimates = {
'initial': (30, 60), # 초기 설정/구조
'feature': (60, 180), # 기능 구현
'bugfix': (15, 45), # 버그 수정
'docs': (10, 30), # 문서화
'refactor': (45, 120), # 리팩토링
'test': (20, 60), # 테스트 추가
'style': (5, 20), # 스타일/포맷팅
'chore': (10, 30), # 잡다한 작업
'default': (30, 90) # 기본값
}
# 커밋 메시지 패턴 매칭
self.commit_patterns = {
'initial': [r'^(initial|init|setup|scaffold)', r'first commit', r'project setup'],
'feature': [r'^(feat|feature|add)', r'implement', r'create', r'build'],
'bugfix': [r'^(fix|bug)', r'resolve', r'patch', r'correct'],
'docs': [r'^(docs|doc)', r'readme', r'documentation', r'comment'],
'refactor': [r'^refactor', r'restructure', r'reorganize', r'cleanup'],
'test': [r'^test', r'spec', r'unit test', r'integration test'],
'style': [r'^style', r'format', r'lint', r'prettier'],
'chore': [r'^chore', r'update', r'bump', r'dependency', r'config']
}
def get_commit_log(self, repo_path: str = ".", author: str = None, since: str = None, until: str = None) -> List[Dict]:
"""
Git 커밋 로그를 가져옵니다.
Args:
repo_path: Git 저장소 경로
author: 특정 작성자 필터링
since: 시작 날짜 (YYYY-MM-DD)
until: 종료 날짜 (YYYY-MM-DD)
Returns:
커밋 정보 리스트
"""
cmd = [
'git', 'log',
'--pretty=format:%H|%ad|%an|%s|%b',
'--date=iso',
'--all'
]
if author:
cmd.extend(['--author', author])
if since:
cmd.extend(['--since', since])
if until:
cmd.extend(['--until', until])
try:
result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True, check=True)
commits = []
for line in result.stdout.strip().split('\n'):
if not line:
continue
parts = line.split('|', 4)
if len(parts) >= 4:
commit_hash, date_str, author, message = parts[:4]
body = parts[4] if len(parts) > 4 else ""
# 날짜 파싱
commit_date = datetime.fromisoformat(date_str.replace(' +', '+').replace(' -', '-'))
commits.append({
'hash': commit_hash,
'date': commit_date,
'author': author,
'message': message,
'body': body,
'full_message': f"{message}\n{body}".strip()
})
return commits
except subprocess.CalledProcessError as e:
print(f"Git 명령 실행 오류: {e}")
return []
except Exception as e:
print(f"커밋 로그 분석 오류: {e}")
return []
def classify_commit(self, commit_message: str) -> str:
"""
커밋 메시지를 분류합니다.
Args:
commit_message: 커밋 메시지
Returns:
커밋 유형
"""
message_lower = commit_message.lower()
for commit_type, patterns in self.commit_patterns.items():
for pattern in patterns:
if re.search(pattern, message_lower):
return commit_type
return 'default'
def estimate_time(self, commit_type: str, message_length: int = 0) -> int:
"""
커밋 유형과 메시지 길이를 기반으로 개발 시간을 추정합니다.
Args:
commit_type: 커밋 유형
message_length: 커밋 메시지 길이
Returns:
추정 개발 시간 (분)
"""
min_time, max_time = self.time_estimates.get(commit_type, self.time_estimates['default'])
# 메시지 길이를 고려한 시간 조정
if message_length > 100:
# 긴 메시지는 복잡한 작업일 가능성이 높음
estimated_time = max_time
elif message_length < 20:
# 짧은 메시지는 간단한 작업일 가능성이 높음
estimated_time = min_time
else:
# 중간 길이는 평균값
estimated_time = (min_time + max_time) // 2
return estimated_time
def summarize_commits_with_ai(self, commits: List[str]) -> str:
"""
OpenAI API를 사용하여 커밋 메시지들을 요약합니다.
Args:
commits: 커밋 메시지 리스트
Returns:
요약된 내용
"""
if not self.openai_client:
return "; ".join(commits[:3]) + ("..." if len(commits) > 3 else "")
try:
commit_text = "\n".join(commits)
response = self.openai_client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content": "다음 커밋 메시지들을 한국어로 간단히 요약해주세요. 주요 작업 내용을 중심으로 50자 이내로 요약해주세요."
},
{
"role": "user",
"content": commit_text
}
],
max_tokens=100,
temperature=0.3
)
return response.choices[0].message.content.strip()
except Exception as e:
print(f"OpenAI API 오류: {e}")
return "; ".join(commits[:3]) + ("..." if len(commits) > 3 else "")
def analyze_commits(self, commits: List[Dict]) -> pd.DataFrame:
"""
커밋들을 분석하여 일별 개발 시간을 계산합니다.
Args:
commits: 커밋 정보 리스트
Returns:
분석 결과 DataFrame
"""
daily_data = defaultdict(lambda: {
'commits': [],
'commit_messages': [],
'total_time': 0,
'time_ranges': []
})
for commit in commits:
date_key = commit['date'].strftime('%Y-%m-%d')
hour = commit['date'].hour
# 시간대 분류
if 6 <= hour < 12:
time_period = "오전"
elif 12 <= hour < 18:
time_period = "오후"
elif 18 <= hour < 22:
time_period = "저녁"
else:
time_period = "야간"
commit_type = self.classify_commit(commit['message'])
estimated_time = self.estimate_time(commit_type, len(commit['full_message']))
daily_data[date_key]['commits'].append(commit)
daily_data[date_key]['commit_messages'].append(commit['message'])
daily_data[date_key]['total_time'] += estimated_time
daily_data[date_key]['time_ranges'].append(time_period)
# DataFrame 생성
results = []
for date, data in sorted(daily_data.items()):
# 가장 빈번한 시간대 찾기
most_common_time = max(set(data['time_ranges']), key=data['time_ranges'].count)
# 커밋 요약
summary = self.summarize_commits_with_ai(data['commit_messages'])
results.append({
'일자': date,
'시간대': most_common_time,
'커밋 수': len(data['commits']),
'개발작업 추정시간 (분)': data['total_time'],
'커밋내용요약': summary
})
return pd.DataFrame(results)
def generate_report(self, df: pd.DataFrame, output_file: str = None):
"""
분석 보고서를 생성합니다.
Args:
df: 분석 결과 DataFrame
output_file: 출력 파일명 (선택사항)
"""
print("=" * 80)
print("커밋 로그 개발 시간 분석 보고서")
print("=" * 80)
print()
# 요약 통계
total_commits = df['커밋 수'].sum()
total_time_minutes = df['개발작업 추정시간 (분)'].sum()
total_time_hours = total_time_minutes / 60
avg_time_per_commit = total_time_minutes / total_commits if total_commits > 0 else 0
print(f"📊 전체 통계:")
print(f" • 총 커밋 수: {total_commits:,}개")
print(f" • 총 개발 시간: {total_time_minutes:,}분 ({total_time_hours:.1f}시간)")
print(f" • 커밋당 평균 시간: {avg_time_per_commit:.1f}분")
print(f" • 분석 기간: {df['일자'].min()} ~ {df['일자'].max()}")
print()
# 일별 상세 분석
print("📅 일별 상세 분석:")
print(df.to_string(index=False))
print()
# 시간대별 분석
time_analysis = df.groupby('시간대').agg({
'커밋 수': 'sum',
'개발작업 추정시간 (분)': 'sum'
}).reset_index()
print("🕐 시간대별 분석:")
print(time_analysis.to_string(index=False))
print()
# 파일 저장
if output_file:
df.to_csv(output_file, index=False, encoding='utf-8-sig')
print(f"💾 결과가 {output_file}에 저장되었습니다.")
def main():
parser = argparse.ArgumentParser(description='GitHub 커밋 로그 개발 시간 분석')
parser.add_argument('--repo', '-r', default='.', help='Git 저장소 경로 (기본값: 현재 디렉토리)')
parser.add_argument('--author', '-a', help='특정 작성자 필터링')
parser.add_argument('--since', '-s', help='시작 날짜 (YYYY-MM-DD)')
parser.add_argument('--until', '-u', help='종료 날짜 (YYYY-MM-DD)')
parser.add_argument('--output', '-o', help='출력 파일명 (.csv)')
parser.add_argument('--openai-key', help='OpenAI API 키')
args = parser.parse_args()
# 분석기 초기화
analyzer = CommitAnalyzer(openai_api_key=args.openai_key)
print("🔍 커밋 로그를 분석하는 중...")
# 커밋 로그 가져오기
commits = analyzer.get_commit_log(
repo_path=args.repo,
author=args.author,
since=args.since,
until=args.until
)
if not commits:
print("❌ 커밋 로그를 찾을 수 없습니다.")
return
print(f"📈 {len(commits)}개의 커밋을 발견했습니다.")
# 커밋 분석
df = analyzer.analyze_commits(commits)
# 보고서 생성
analyzer.generate_report(df, args.output)
if __name__ == "__main__":
main()이제 스크립트 사용을 위한 requirements.txt 파일도 생성해드리겠습니다.
pandas>=2.0.0
openai>=1.0.0
python-dateutil>=2.8.0마지막으로 사용 예시와 설명을 포함한 README 파일도 작성해드리겠습니다.
사용 가이드 (README.md)
# GitHub 커밋 로그 개발 시간 분석 스크립트
Git 저장소의 커밋 로그를 분석하여 개발 시간을 추정하고, OpenAI API를 사용하여 커밋 내용을 요약하는 Python 스크립트입니다.
## 주요 기능
- 📊 커밋 로그 자동 분석 및 개발 시간 추정
- 🤖 OpenAI API를 활용한 커밋 메시지 요약
- 📅 일별, 시간대별 개발 활동 분석
- 📈 상세한 통계 보고서 생성
- 💾 CSV 파일로 결과 내보내기
## 설치 방법
1. 필요한 패키지 설치:
```bash
pip install -r requirements.txt- OpenAI API 키 설정 (선택사항):
export OPENAI_API_KEY="your-openai-api-key"사용 방법
기본 사용법
python commit_analyzer.py고급 사용법
# 특정 저장소 분석
python commit_analyzer.py --repo /path/to/repository
# 특정 작성자만 분석
python commit_analyzer.py --author "작성자명"
# 날짜 범위 지정
python commit_analyzer.py --since 2024-01-01 --until 2024-12-31
# 결과를 CSV 파일로 저장
python commit_analyzer.py --output result.csv
# OpenAI API 키 직접 지정
python commit_analyzer.py --openai-key "your-api-key"
# 모든 옵션 조합
python commit_analyzer.py --repo ./my-project --author "김개발" --since 2024-01-01 --output analysis.csv커맨드 라인 옵션
| 옵션 | 설명 | 예시 |
|---|---|---|
--repo, -r | Git 저장소 경로 | --repo /path/to/repo |
--author, -a | 특정 작성자 필터링 | --author "김개발" |
--since, -s | 시작 날짜 (YYYY-MM-DD) | --since 2024-01-01 |
--until, -u | 종료 날짜 (YYYY-MM-DD) | --until 2024-12-31 |
--output, -o | 출력 CSV 파일명 | --output result.csv |
--openai-key | OpenAI API 키 | --openai-key "sk-..." |
개발 시간 추정 기준
스크립트는 커밋 메시지를 분석하여 다음과 같이 개발 시간을 추정합니다:
| 커밋 유형 | 추정 시간 (분) | 예시 키워드 |
|---|---|---|
| 초기 설정 | 30-60 | initial, setup, scaffold |
| 기능 구현 | 60-180 | feat, feature, implement |
| 버그 수정 | 15-45 | fix, bug, resolve |
| 문서화 | 10-30 | docs, readme, documentation |
| 리팩토링 | 45-120 | refactor, restructure |
| 테스트 | 20-60 | test, spec, unit test |
| 스타일링 | 5-20 | style, format, lint |
| 기타 작업 | 10-30 | chore, update, config |
출력 예시
================================================================================
커밋 로그 개발 시간 분석 보고서
================================================================================
📊 전체 통계:
• 총 커밋 수: 45개
• 총 개발 시간: 3,240분 (54.0시간)
• 커밋당 평균 시간: 72.0분
• 분석 기간: 2024-01-15 ~ 2024-02-10
📅 일별 상세 분석:
일자 시간대 커밋 수 개발작업 추정시간 (분) 커밋내용요약
2024-01-15 오후 3 180 프로젝트 초기 설정 및 구조 생성
2024-01-16 오전 5 420 사용자 인증 기능 구현
2024-01-17 저녁 2 120 버그 수정 및 테스트 추가
...
🕐 시간대별 분석:
시간대 커밋 수 개발작업 추정시간 (분)
오전 15 1080
오후 20 1440
저녁 8 480
야간 2 240참고사항
- OpenAI API 키가 없어도 기본적인 분석은 가능합니다 (요약 기능만 제한됨)
- 개발 시간 추정은 커밋 메시지 패턴을 기반으로 한 근사치입니다
- 실제 개발 시간과는 차이가 있을 수 있으니 참고용으로 사용하세요
- Git 저장소가 있는 디렉토리에서 실행해야 합니다
문제 해결
Git 명령 오류
- Git이 설치되어 있는지 확인하세요
- 현재 디렉토리가 Git 저장소인지 확인하세요
OpenAI API 오류
- API 키가 올바른지 확인하세요
- API 사용량 한도를 확인하세요
- 네트워크 연결을 확인하세요
한글 인코딩 문제
- 시스템 로케일이 UTF-8을 지원하는지 확인하세요
- CSV 파일은 UTF-8-BOM으로 저장됩니다
.
GitHub 커밋 로그를 분석하여 개발 추정 시간을 산출하는 스크립트를 작성해드리겠습니다. OpenAI API를 연동하여 커밋 내용을 요약하는 기능도 포함하겠습니다.이제 스크립트 사용을 위한 requirements.txt 파일도 생성해드리겠습니다.마지막으로 사용 예시와 설명을 포함한 README 파일도 작성해드리겠습니다.
GitHub 커밋 로그를 분석하여 개발 시간을 추정하는 완전한 스크립트를 작성했습니다!
주요 특징:
🔍 자동 분석 기능
- Git 커밋 로그 자동 추출
- 커밋 메시지 패턴 분석으로 작업 유형 분류
- 작업 유형별 개발 시간 추정
🤖 AI 요약 기능
- OpenAI API 연동으로 커밋 메시지 자동 요약
- 한국어로 간결한 요약 제공
📊 상세 분석 보고서
- 일별/시간대별 개발 활동 분석
- 전체 통계 및 CSV 내보내기
- 요청하신 형식의 표 생성
사용 방법:
- 기본 사용 (현재 디렉토리의 Git 저장소 분석):
python commit_analyzer.py- 특정 저장소 분석:
python commit_analyzer.py --repo /path/to/sechan9999/sfguide-build-data-agents-using-snowflake-cortex-ai- OpenAI API 키와 함께 사용:
export OPENAI_API_KEY="your-key"
python commit_analyzer.py --output analysis.csv이 스크립트는 요청하신 대로 |일자|시간대|커밋 수|개발작업 추정시간 (분)|커밋내용요약
형식의 표를 생성하며, OpenAI API를 통해 커밋 내용을 한국어로 요약해줍니다.
더 나은 세상은 가능하다를 믿고 실천하는 활동가