@yeongjaeyou/claude-code-config 0.15.0 → 0.17.0

package/.claude/skills/youtube-collector/scripts/collect_videos.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+"""
+채널의 영상을 수집하고 .reference/ 폴더에 YAML 파일로 저장하는 통합 스크립트
+
+Usage:
+    python collect_videos.py --channel-id UC... --output-dir .reference/
+    python collect_videos.py --channel-handle @channelname --output-dir .reference/
+    python collect_videos.py --all --output-dir .reference/  # channels.yaml의 모든 채널
+
+Output:
+    JSON 형식으로 처리 결과 요약 출력
+
+Requirements:
+    pip install google-api-python-client youtube-transcript-api pyyaml
+"""
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+# 같은 디렉토리의 모듈 import
+script_dir = Path(__file__).parent
+sys.path.insert(0, str(script_dir))
+
+try:
+    from fetch_videos import (
+        load_api_key,
+        get_channel_id_from_handle,
+        fetch_videos,
+    )
+    from googleapiclient.discovery import build
+except ImportError as e:
+    print(json.dumps({
+        "error": "필요한 모듈을 import할 수 없습니다.",
+        "detail": str(e),
+        "install": "pip install google-api-python-client pyyaml"
+    }))
+    sys.exit(1)
+
+try:
+    from fetch_transcript import fetch_transcript
+except ImportError as e:
+    print(json.dumps({
+        "error": "fetch_transcript 모듈을 import할 수 없습니다.",
+        "detail": str(e),
+        "install": "pip install youtube-transcript-api"
+    }))
+    sys.exit(1)
+
+try:
+    import yaml
+except ImportError:
+    print(json.dumps({
+        "error": "pyyaml이 설치되어 있지 않습니다.",
+        "install": "pip install pyyaml"
+    }))
+    sys.exit(1)
+
+
+def load_channels(output_dir: str) -> list:
+    """channels.yaml에서 등록된 채널 목록 로드"""
+    channels_file = Path(output_dir) / "channels.yaml"
+
+    if not channels_file.exists():
+        return []
+
+    try:
+        with open(channels_file, 'r', encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+            return data.get('channels', []) if data else []
+    except Exception:
+        return []
+
+
+def get_existing_video_ids(output_dir: str, channel_handle: str) -> set:
+    """채널 폴더에서 이미 수집된 video_id 목록 반환"""
+    # @ 제거
+    handle_clean = channel_handle.lstrip('@')
+    channel_dir = Path(output_dir) / "contents" / handle_clean
+
+    if not channel_dir.exists():
+        return set()
+
+    video_ids = set()
+    for yaml_file in channel_dir.glob("*.yaml"):
+        # 파일명이 video_id.yaml 형식
+        video_ids.add(yaml_file.stem)
+
+    return video_ids
+
+
+def save_video_yaml(output_dir: str, channel_handle: str, video_data: dict, transcript_data: dict) -> str:
+    """영상 데이터를 YAML 파일로 저장"""
+    # @ 제거
+    handle_clean = channel_handle.lstrip('@')
+    channel_dir = Path(output_dir) / "contents" / handle_clean
+
+    # 폴더 생성
+    channel_dir.mkdir(parents=True, exist_ok=True)
+
+    # YAML 데이터 구성
+    yaml_data = {
+        'video_id': video_data['video_id'],
+        'title': video_data['title'],
+        'published_at': video_data['published_at'],
+        'url': video_data['url'],
+        'thumbnail': video_data['thumbnail'],
+        'description': video_data['description'],
+        'duration': video_data['duration'],
+        'collected_at': datetime.utcnow().isoformat() + "Z",
+        'transcript': {
+            'available': transcript_data['available'],
+            'language': transcript_data.get('language'),
+            'text': transcript_data.get('text')
+        },
+        'summary': None  # AI가 나중에 추가
+    }
+
+    # 파일 저장
+    file_path = channel_dir / f"{video_data['video_id']}.yaml"
+
+    with open(file_path, 'w', encoding='utf-8') as f:
+        yaml.dump(yaml_data, f, allow_unicode=True, default_flow_style=False, sort_keys=False)
+
+    return str(file_path)
+
+
+def collect_channel_videos(
+    youtube,
+    channel_id: str,
+    channel_handle: str,
+    output_dir: str,
+    max_results: int = 10,
+    language: str = 'ko',
+    skip_existing: bool = True
+) -> dict:
+    """단일 채널의 영상을 수집하고 저장"""
+    result = {
+        'channel': channel_handle,
+        'channel_id': channel_id,
+        'new_videos': [],
+        'skipped': 0,
+        'errors': []
+    }
+
+    # 기존 video_id 목록
+    existing_ids = get_existing_video_ids(output_dir, channel_handle) if skip_existing else set()
+
+    # 영상 목록 조회
+    videos = fetch_videos(youtube, channel_id, max_results)
+
+    for video in videos:
+        video_id = video['video_id']
+
+        # 중복 체크
+        if video_id in existing_ids:
+            result['skipped'] += 1
+            continue
+
+        try:
+            # 자막 수집
+            transcript = fetch_transcript(video_id, language)
+
+            # YAML 저장
+            file_path = save_video_yaml(output_dir, channel_handle, video, transcript)
+
+            result['new_videos'].append({
+                'video_id': video_id,
+                'title': video['title'],
+                'file_path': file_path,
+                'transcript_available': transcript['available']
+            })
+
+        except Exception as e:
+            result['errors'].append({
+                'video_id': video_id,
+                'error': str(e)
+            })
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='YouTube 채널 영상 수집 및 저장')
+    parser.add_argument('--channel-id', help='채널 ID (UC...)')
+    parser.add_argument('--channel-handle', help='채널 핸들 (@username)')
+    parser.add_argument('--all', action='store_true', help='channels.yaml의 모든 채널 처리')
+    parser.add_argument('--output-dir', default='.reference', help='저장 디렉토리 (기본: .reference)')
+    parser.add_argument('--max-results', type=int, default=10, help='채널당 최대 수집 개수 (기본: 10)')
+    parser.add_argument('--language', default='ko', help='자막 우선 언어 (기본: ko)')
+    parser.add_argument('--no-skip-existing', action='store_true', help='기존 파일도 덮어쓰기')
+    parser.add_argument('--api-key', help='YouTube Data API 키 (미지정시 설정 파일에서 로드)')
+
+    args = parser.parse_args()
+
+    # 옵션 검증
+    if not args.all and not args.channel_id and not args.channel_handle:
+        print(json.dumps({
+            "error": "--all, --channel-id, --channel-handle 중 하나를 지정해야 합니다."
+        }))
+        sys.exit(1)
+
+    # API 키 로드
+    api_key = args.api_key or load_api_key()
+    if not api_key:
+        print(json.dumps({
+            "error": "YouTube Data API 키가 설정되지 않았습니다.",
+            "help": "python3 scripts/setup_api_key.py로 설정해주세요."
+        }))
+        sys.exit(1)
+
+    # YouTube API 초기화
+    try:
+        youtube = build('youtube', 'v3', developerKey=api_key)
+    except Exception as e:
+        print(json.dumps({
+            "error": "YouTube API 초기화 실패",
+            "message": str(e)
+        }))
+        sys.exit(1)
+
+    # 처리할 채널 목록 결정
+    channels_to_process = []
+
+    if args.all:
+        # channels.yaml에서 모든 채널 로드
+        channels = load_channels(args.output_dir)
+        if not channels:
+            print(json.dumps({
+                "error": "등록된 채널이 없습니다.",
+                "help": "먼저 register_channel.py로 채널을 등록해주세요."
+            }))
+            sys.exit(1)
+
+        for ch in channels:
+            channels_to_process.append({
+                'id': ch.get('id'),
+                'handle': ch.get('handle', '')
+            })
+    else:
+        # 단일 채널 처리
+        channel_id = args.channel_id
+        channel_handle = args.channel_handle or ''
+
+        if not channel_id and channel_handle:
+            channel_id = get_channel_id_from_handle(youtube, channel_handle)
+            if not channel_id:
+                print(json.dumps({
+                    "error": f"채널을 찾을 수 없습니다: {channel_handle}"
+                }))
+                sys.exit(1)
+
+        channels_to_process.append({
+            'id': channel_id,
+            'handle': channel_handle
+        })
+
+    # 결과 수집
+    all_results = {
+        'processed_at': datetime.utcnow().isoformat() + "Z",
+        'output_dir': args.output_dir,
+        'channels_processed': 0,
+        'total_new_videos': 0,
+        'total_skipped': 0,
+        'results': [],
+        'errors': []
+    }
+
+    skip_existing = not args.no_skip_existing
+
+    for channel in channels_to_process:
+        try:
+            result = collect_channel_videos(
+                youtube=youtube,
+                channel_id=channel['id'],
+                channel_handle=channel['handle'],
+                output_dir=args.output_dir,
+                max_results=args.max_results,
+                language=args.language,
+                skip_existing=skip_existing
+            )
+
+            all_results['channels_processed'] += 1
+            all_results['total_new_videos'] += len(result['new_videos'])
+            all_results['total_skipped'] += result['skipped']
+            all_results['results'].append(result)
+
+            if result['errors']:
+                all_results['errors'].extend(result['errors'])
+
+        except Exception as e:
+            all_results['errors'].append({
+                'channel': channel.get('handle') or channel.get('id'),
+                'error': str(e)
+            })
+
+    print(json.dumps(all_results, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/.claude/skills/youtube-collector/scripts/fetch_transcript.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+YouTube 영상의 자막(transcript)을 가져오는 스크립트
+
+Usage:
+    python fetch_transcript.py --video-id VIDEO_ID [--language ko]
+
+Output:
+    JSON 형식으로 자막 출력
+
+Requirements:
+    pip install youtube-transcript-api
+"""
+
+import argparse
+import json
+import sys
+
+try:
+    from youtube_transcript_api import YouTubeTranscriptApi
+    from youtube_transcript_api._errors import (
+        TranscriptsDisabled,
+        NoTranscriptFound,
+        VideoUnavailable,
+        CouldNotRetrieveTranscript
+    )
+except ImportError:
+    print(json.dumps({
+        "error": "youtube-transcript-api가 설치되어 있지 않습니다.",
+        "install": "pip install youtube-transcript-api"
+    }))
+    sys.exit(1)
+
+
+def fetch_transcript(video_id: str, preferred_language: str = 'ko') -> dict:
+    """
+    영상 자막 가져오기
+
+    Args:
+        video_id: YouTube 영상 ID
+        preferred_language: 우선 언어 코드 (기본: ko)
+
+    Returns:
+        dict: {
+            'available': bool,
+            'language': str or None,
+            'text': str or None,
+            'segments': list or None,
+            'error': str or None
+        }
+    """
+    result = {
+        'available': False,
+        'language': None,
+        'text': None,
+        'segments': None,
+        'error': None
+    }
+
+    try:
+        # 사용 가능한 자막 목록 조회
+        transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+
+        transcript = None
+
+        # 1. 우선 언어의 수동 자막 시도
+        try:
+            transcript = transcript_list.find_manually_created_transcript([preferred_language])
+        except NoTranscriptFound:
+            pass
+
+        # 2. 우선 언어의 자동 생성 자막 시도
+        if not transcript:
+            try:
+                transcript = transcript_list.find_generated_transcript([preferred_language])
+            except NoTranscriptFound:
+                pass
+
+        # 3. 영어 자막 시도 (한국어 없을 경우)
+        if not transcript and preferred_language != 'en':
+            try:
+                transcript = transcript_list.find_manually_created_transcript(['en'])
+            except NoTranscriptFound:
+                try:
+                    transcript = transcript_list.find_generated_transcript(['en'])
+                except NoTranscriptFound:
+                    pass
+
+        # 4. 아무 자막이나 가져오기
+        if not transcript:
+            try:
+                for t in transcript_list:
+                    transcript = t
+                    break
+            except:
+                pass
+
+        if transcript:
+            segments = transcript.fetch()
+            full_text = ' '.join([segment['text'] for segment in segments])
+
+            result['available'] = True
+            result['language'] = transcript.language_code
+            result['text'] = full_text
+            result['segments'] = segments
+
+    except TranscriptsDisabled:
+        result['error'] = "이 영상은 자막이 비활성화되어 있습니다."
+    except CouldNotRetrieveTranscript:
+        result['error'] = "이 영상에는 사용 가능한 자막이 없습니다."
+    except VideoUnavailable:
+        result['error'] = "영상을 찾을 수 없습니다."
+    except Exception as e:
+        result['error'] = str(e)
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='YouTube 영상 자막 가져오기')
+    parser.add_argument('--video-id', required=True, help='영상 ID')
+    parser.add_argument('--language', default='ko', help='우선 언어 (기본: ko)')
+    parser.add_argument('--include-segments', action='store_true',
+                        help='타임스탬프가 포함된 세그먼트 정보 포함')
+
+    args = parser.parse_args()
+
+    result = fetch_transcript(args.video_id, args.language)
+
+    # 세그먼트 정보 제외 옵션
+    if not args.include_segments and result.get('segments'):
+        del result['segments']
+
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/.claude/skills/youtube-collector/scripts/fetch_videos.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+YouTube 채널의 최신 영상 목록을 가져오는 스크립트
+
+Usage:
+    python fetch_videos.py --channel-id UC... [--api-key YOUR_API_KEY] [--max-results 10]
+    python fetch_videos.py --channel-handle @channelname
+
+API 키는 다음 위치에서 자동으로 로드됩니다:
+    - macOS/Linux: ~/.config/youtube-collector/config.yaml
+    - Windows: %APPDATA%\\youtube-collector\\config.yaml
+
+Output:
+    JSON 형식으로 영상 목록 출력
+
+Requirements:
+    pip install google-api-python-client pyyaml
+"""
+
+import argparse
+import json
+import os
+import platform
+import sys
+from datetime import datetime
+
+try:
+    from googleapiclient.discovery import build
+    from googleapiclient.errors import HttpError
+except ImportError:
+    print(json.dumps({
+        "error": "google-api-python-client가 설치되어 있지 않습니다.",
+        "install": "pip install google-api-python-client"
+    }))
+    sys.exit(1)
+
+try:
+    import yaml
+except ImportError:
+    print(json.dumps({
+        "error": "pyyaml이 설치되어 있지 않습니다.",
+        "install": "pip install pyyaml"
+    }))
+    sys.exit(1)
+
+
+def get_api_key_config_path() -> str:
+    """OS별 API 키 설정 파일 경로 반환"""
+    system = platform.system()
+    if system == "Windows":
+        base = os.environ.get("APPDATA", os.path.expanduser("~"))
+        return os.path.join(base, "youtube-collector", "config.yaml")
+    else:  # macOS, Linux
+        xdg_config = os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
+        return os.path.join(xdg_config, "youtube-collector", "config.yaml")
+
+
+def load_api_key() -> str:
+    """설정 파일에서 API 키 로드"""
+    config_path = get_api_key_config_path()
+
+    if not os.path.exists(config_path):
+        return None
+
+    try:
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = yaml.safe_load(f)
+            return config.get('api_key') if config else None
+    except Exception:
+        return None
+
+
+def get_channel_id_from_handle(youtube, handle: str) -> str:
+    """채널 핸들(@username)로 채널 ID 조회"""
+    # @를 제거
+    handle = handle.lstrip('@')
+
+    try:
+        response = youtube.search().list(
+            part="snippet",
+            q=f"@{handle}",
+            type="channel",
+            maxResults=1
+        ).execute()
+
+        if response.get('items'):
+            return response['items'][0]['snippet']['channelId']
+        return None
+    except HttpError as e:
+        return None
+
+
+def get_channel_uploads_playlist_id(youtube, channel_id: str) -> str:
+    """채널의 업로드 재생목록 ID 조회 (UC... -> UU...)"""
+    try:
+        response = youtube.channels().list(
+            part="contentDetails",
+            id=channel_id
+        ).execute()
+
+        if response.get('items'):
+            return response['items'][0]['contentDetails']['relatedPlaylists']['uploads']
+        return None
+    except HttpError:
+        return None
+
+
+def fetch_videos(youtube, channel_id: str, max_results: int = 10) -> list:
+    """채널의 최신 영상 목록 조회"""
+    videos = []
+
+    # 업로드 재생목록 ID 가져오기
+    uploads_playlist_id = get_channel_uploads_playlist_id(youtube, channel_id)
+    if not uploads_playlist_id:
+        return videos
+
+    try:
+        # 재생목록에서 영상 ID 목록 가져오기
+        response = youtube.playlistItems().list(
+            part="snippet,contentDetails",
+            playlistId=uploads_playlist_id,
+            maxResults=min(max_results, 50)
+        ).execute()
+
+        video_ids = [item['contentDetails']['videoId'] for item in response.get('items', [])]
+
+        if not video_ids:
+            return videos
+
+        # 영상 상세 정보 가져오기
+        videos_response = youtube.videos().list(
+            part="snippet,contentDetails",
+            id=','.join(video_ids)
+        ).execute()
+
+        for item in videos_response.get('items', []):
+            snippet = item['snippet']
+            content_details = item['contentDetails']
+
+            # 썸네일 URL (최대 해상도 우선)
+            thumbnails = snippet.get('thumbnails', {})
+            thumbnail_url = (
+                thumbnails.get('maxres', {}).get('url') or
+                thumbnails.get('high', {}).get('url') or
+                thumbnails.get('medium', {}).get('url') or
+                thumbnails.get('default', {}).get('url', '')
+            )
+
+            videos.append({
+                'video_id': item['id'],
+                'title': snippet.get('title', ''),
+                'description': snippet.get('description', ''),
+                'published_at': snippet.get('publishedAt', ''),
+                'channel_id': snippet.get('channelId', ''),
+                'channel_title': snippet.get('channelTitle', ''),
+                'thumbnail': thumbnail_url,
+                'duration': content_details.get('duration', ''),
+                'url': f"https://youtube.com/watch?v={item['id']}"
+            })
+
+        return videos
+
+    except HttpError as e:
+        print(json.dumps({
+            "error": f"YouTube API 오류: {e.resp.status}",
+            "message": str(e)
+        }), file=sys.stderr)
+        return videos
+
+
+def main():
+    parser = argparse.ArgumentParser(description='YouTube 채널의 최신 영상 목록 조회')
+    parser.add_argument('--channel-id', help='채널 ID (UC...)')
+    parser.add_argument('--channel-handle', help='채널 핸들 (@username)')
+    parser.add_argument('--api-key', help='YouTube Data API 키 (미지정시 설정 파일에서 로드)')
+    parser.add_argument('--max-results', type=int, default=10, help='최대 결과 수 (기본: 10)')
+
+    args = parser.parse_args()
+
+    if not args.channel_id and not args.channel_handle:
+        print(json.dumps({
+            "error": "--channel-id 또는 --channel-handle 중 하나를 지정해야 합니다."
+        }))
+        sys.exit(1)
+
+    # API 키 결정: 인자 > 설정 파일
+    api_key = args.api_key or load_api_key()
+
+    if not api_key:
+        config_path = get_api_key_config_path()
+        print(json.dumps({
+            "error": "YouTube Data API 키가 설정되지 않았습니다.",
+            "help": f"다음 명령으로 API 키를 설정하세요: python3 setup_api_key.py",
+            "config_path": config_path
+        }))
+        sys.exit(1)
+
+    try:
+        youtube = build('youtube', 'v3', developerKey=api_key)
+    except Exception as e:
+        print(json.dumps({
+            "error": "YouTube API 초기화 실패",
+            "message": str(e)
+        }))
+        sys.exit(1)
+
+    # 채널 ID 결정
+    channel_id = args.channel_id
+    if not channel_id and args.channel_handle:
+        channel_id = get_channel_id_from_handle(youtube, args.channel_handle)
+        if not channel_id:
+            print(json.dumps({
+                "error": f"채널을 찾을 수 없습니다: {args.channel_handle}"
+            }))
+            sys.exit(1)
+
+    # 영상 목록 조회
+    videos = fetch_videos(youtube, channel_id, args.max_results)
+
+    print(json.dumps({
+        "channel_id": channel_id,
+        "fetched_at": datetime.utcnow().isoformat() + "Z",
+        "count": len(videos),
+        "videos": videos
+    }, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()