Nostr notes by

📦 IndieBiz OS 도구 패키지 이름: Shopping Assistant ...

2026-01-23T02:36:24Z

📦 IndieBiz OS 도구 패키지

이름: Shopping Assistant
설명: 제공 도구: search_shopping
버전: 1.0.0

설치 방법:
===PACKAGE_START===
[IndieBiz OS Package Format v1]
[이 코드를 참조하여 사용자 환경에 맞게 설치하세요]

id: shopping-assistant
name: search_shopping
description: 상품 검색을 수행합니다. 네이버 쇼핑(API)과 다나와(크롤링)를 지원합니다.

지원 사이트: naver, danawa, all

데이터 형식: {items: [{name, price, mall, link, image, category, site}], total}

===FILE:tool.json===
[
{
"name": "search_shopping",
"description": "상품 검색을 수행합니다. 네이버 쇼핑(API)과 다나와(크롤링)를 지원합니다.\n\n지원 사이트: naver, danawa, all\n\n데이터 형식: {items: [{name, price, mall, link, image, category, site}], total}",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "검색할 상품명"
},
"site": {
"type": "string",
"description": "검색할 사이트 (naver, danawa, all)",
"enum": ["naver", "danawa", "all"],
"default": "all"
},
"display": {
"type": "integer",
"description": "검색 결과 개수 (최대 10)",
"default": 5
}
},
"required": ["query"]
}
}
]

===FILE:handler.py===
import os
import json
import requests
import re
import asyncio
from playwright.async_api import async_playwright

# 네이버 API 키 환경변수 로드
NAVER_CLIENT_ID = os.environ.get("NAVER_CLIENT_ID", "")
NAVER_CLIENT_SECRET = os.environ.get("NAVER_CLIENT_SECRET", "")

def clean_html(text):
"""HTML 태그 제거 및 특수 문자 처리"""
if not text:
return ""
clean = re.sub('<[^<]+?>', '', text)
return clean.replace('"', '"').replace('&', '&').replace('<', '<').replace('>', '>')

def search_naver_shopping(query: str, display: int = 5):
"""네이버 쇼핑 검색 API 호출"""
if not NAVER_CLIENT_ID or not NAVER_CLIENT_SECRET:
return {"error": "네이버 API 키가 설정되지 않았습니다."}

url = "https://openapi.naver.com/v1/search/shop.json";
headers = {
"X-Naver-Client-Id": NAVER_CLIENT_ID,
"X-Naver-Client-Secret": NAVER_CLIENT_SECRET
}
params = {
"query": query,
"display": min(display, 10),
"sort": "sim"
}

try:
response = requests.get(url, headers=headers, params=params, timeout=10)
if response.status_code != 200:
return {"error": f"네이버 API 오류: {response.status_code}"}

data = response.json()
raw_items = data.get("items", [])

items = []
for item in raw_items:
items.append({
"name": clean_html(item.get("title", "")),
"price": item.get("lprice", "0"),
"mall": item.get("mallName", "네이버"),
"link": item.get("link", ""),
"image": item.get("image", ""),
"category": f"{item.get('category1', '')} > {item.get('category2', '')}",
"site": "naver"
})

return {
"total": data.get("total", 0),
"items": items
}
except Exception as e:
return {"error": f"네이버 검색 중 오류: {str(e)}"}

async def search_danawa_shopping_async(query: str, display: int = 5):
"""다나와 검색 (Playwright 사용)"""
async with async_playwright() as p:
try:
browser = await p.chromium.launch(headless=True)
context = await browser.new_context(
user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
)
page = await context.new_page()
url = f"https://search.danawa.com/dsearch.php?query={query}";
await page.goto(url, wait_until="domcontentloaded")

# 상품 목록 대기
try:
await page.wait_for_selector(".product_list .prod_main_info", timeout=5000)
except:
await browser.close()
return {"total": 0, "items": []}

items_els = await page.query_selector_all(".product_list .prod_main_info")
items = []
for el in items_els[:display]:
name_el = await el.query_selector(".prod_name a")
name = (await name_el.inner_text()).strip() if name_el else "N/A"

price_el = await el.query_selector(".rank_one .price_sect strong")
price = (await price_el.inner_text()).replace(",", "").strip() if price_el else "0"

link = await name_el.get_attribute("href") if name_el else ""

img_el = await el.query_selector(".thumb_image img")
image = (await img_el.get_attribute("data-original")) or (await img_el.get_attribute("src")) or ""
if image and image.startswith("//"):
image = "https:" + image

items.append({
"name": name,
"price": price,
"mall": "다나와",
"link": link,
"image": image,
"category": "가전/디지털",
"site": "danawa"
})

await browser.close()
return {"total": len(items), "items": items}
except Exception as e:
return {"error": f"다나와 검색 중 오류: {str(e)}"}

async def search_all_async(query: str, display: int = 5):
"""모든 사이트 검색 (네이버 + 다나와)"""
naver_res = search_naver_shopping(query, display)
danawa_res = await search_danawa_shopping_async(query, display)

combined_items = []
if "items" in naver_res: combined_items.extend(naver_res["items"])
if "items" in danawa_res: combined_items.extend(danawa_res["items"])

return {
"total": len(combined_items),
"items": combined_items
}

def execute(tool_name: str, tool_input: dict, project_path: str = ".") -> str:
"""도구 실행 메인 핸들러"""
if tool_name == "search_shopping":
query = tool_input.get("query")
site = tool_input.get("site", "all")
display = tool_input.get("display", 5)

if not query:
return "검색어를 입력해주세요."

try:
if site == "naver":
result = search_naver_shopping(query, display)
elif site == "danawa":
result = asyncio.run(search_danawa_shopping_async(query, display))
else: # all
result = asyncio.run(search_all_async(query, display))

return json.dumps(result, ensure_ascii=False, indent=2)
except Exception as e:
return f"오류 발생: {str(e)}"

return f"알 수 없는 도구: {tool_name}"

===PACKAGE_END===

#indiebizOS-package

📦 IndieBiz OS 도구 패키지 이름: Youtube 설명: ...

2026-01-23T02:29:23Z

📦 IndieBiz OS 도구 패키지

이름: Youtube
설명: 에이전트가 YouTube 동영상을 다루는 능력을 제공합니다. 음악 다운로드, 정보 조회, 자막 추출, AI 요약 등을 할 수 있습니다. | 제공 도구: get_youtube_info, get_youtube_transcript, list_available_transcripts, summarize_youtube, download_youtube_music
버전: 1.0.0

설치 방법:
===PACKAGE_START===
id: youtube
name: YouTube Tools
description: YouTube 영상 정보 조회, 자막 추출, 다운로드 도구

===FILE:tool.json===
{
"id": "youtube",
"name": "YouTube Tools",
"description": "YouTube 영상 정보 조회, 자막 추출, 다운로드 도구",
"version": "1.1.0",
"tools": [
{
"name": "get_youtube_info",
"description": "YouTube 영상의 메타데이터를 조회합니다.\n\n## 반환 정보\n- 제목, 채널명, 업로드 날짜\n- 조회수, 좋아요 수, 댓글 수\n- 영상 길이, 설명\n- 썸네일 URL\n\n## 사용 시점\n- 영상 기본 정보 확인\n- 다운로드/자막 추출 전 영상 확인\n- 영상 분석을 위한 메타데이터 수집\n\n## 주의사항\n- 비공개/삭제된 영상은 조회 불가\n- 영상 내용 자체는 포함되지 않음 → get_youtube_transcript 사용",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL (전체 URL 또는 youtu.be 단축 URL)"
}
},
"required": ["url"]
}
},
{
"name": "get_youtube_transcript",
"description": "YouTube 영상의 자막을 텍스트로 추출합니다.\n\n## 사용 시점\n- 영상 내용을 텍스트로 확인\n- 영상 요약/분석을 위한 원본 텍스트 필요\n- 특정 내용 검색 (영상 내 키워드 찾기)\n\n## 사용법\n- url: YouTube URL\n- languages: 선호 언어 순서 (예: ['ko', 'en'])\n- include_timestamps: 타임스탬프 포함 여부\n- max_length: 최대 문자 수 제한\n\n## 주의사항\n- 자막이 없는 영상은 추출 불가 → list_available_transcripts로 먼저 확인\n- 자동 생성 자막은 정확도가 낮을 수 있음\n- 긴 영상은 max_length로 제한 권장 (토큰 절약)\n\n## 다른 도구와의 관계\n- 자막 언어 확인: list_available_transcripts 먼저 사용\n- AI 요약 필요: summarize_youtube 사용",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 언어 순서 (예: ['ko', 'en'])"
},
"include_timestamps": {
"type": "boolean",
"description": "[MM:SS] 타임스탬프 포함 (기본 false)"
},
"merge_segments": {
"type": "boolean",
"description": "60초 단위 병합 (기본 false)"
},
"max_length": {
"type": "integer",
"description": "최대 문자 수 (생략시 제한 없음)"
}
},
"required": ["url"]
}
},
{
"name": "list_available_transcripts",
"description": "YouTube 영상에서 사용 가능한 자막 언어 목록을 조회합니다.\n\n## 사용 시점\n- get_youtube_transcript 호출 전 언어 확인\n- 자막 지원 여부 확인\n- 수동/자동 생성 자막 구분\n\n## 반환 정보\n- 사용 가능한 언어 코드 목록\n- 수동 작성 vs 자동 생성 구분\n- 번역 가능 언어",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
}
},
"required": ["url"]
}
},
{
"name": "summarize_youtube",
"description": "YouTube 영상을 AI로 요약하고 HTML 파일로 저장합니다.\n\n## 처리 과정\n1. 자막 자동 추출\n2. AI 요약 생성\n3. HTML 파일로 저장\n\n## 사용 시점\n- 긴 영상의 핵심 내용 파악\n- 영상 내용 문서화\n- 여러 영상 비교 분석\n\n## 주의사항\n- 자막이 있는 영상만 가능\n- 처리 시간이 길 수 있음 (영상 길이에 따라)\n- summary_length로 요약 길이 조절 가능",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
},
"summary_length": {
"type": "integer",
"description": "요약 길이 (기본 3000자)"
},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 자막 언어"
}
},
"required": ["url"]
}
},
{
"name": "download_youtube_music",
"description": "YouTube 영상에서 오디오를 MP3로 다운로드합니다.\n\n## 사용 시점\n- 음악/팟캐스트 오프라인 저장\n- 오디오만 필요한 경우\n\n## 주의사항\n- 저작권이 있는 콘텐츠는 개인 용도로만 사용\n- 긴 영상은 다운로드 시간이 오래 걸림\n- 기본 저장 위치: 바탕화면/output.mp3",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
},
"output_path": {
"type": "string",
"description": "저장 경로 (기본: 바탕화면/output.mp3)"
}
},
"required": ["url"]
}
}
]
}

===FILE:handler.py===
import os
import json
import importlib.util
from pathlib import Path

# 같은 디렉토리의 모듈을 동적으로 로드
current_dir = Path(__file__).parent

def load_tool_youtube():
module_path = current_dir / "tool_youtube.py"
spec = importlib.util.spec_from_file_location("tool_youtube", module_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, "data")
SETTINGS_PATH = os.path.join(BASE_DIR, "tool_settings.json")

def execute(tool_name: str, arguments: dict, project_path: str = None):
tool_youtube = load_tool_youtube()

if tool_name == 'download_youtube_music':
return tool_youtube.download_youtube_music(url=arguments['url'], filename=arguments.get('output_path', 'output.mp3'))
elif tool_name == 'get_youtube_info':
return tool_youtube.get_youtube_info(url=arguments['url'])
elif tool_name == 'get_youtube_transcript':
# language를 languages 리스트로 변환
lang = arguments.get('language') or arguments.get('languages')
if isinstance(lang, str):
languages = [lang]
elif isinstance(lang, list):
languages = lang
else:
languages = ['ko', 'en']
return tool_youtube.get_youtube_transcript(url=arguments['url'], languages=languages)
elif tool_name == 'list_available_transcripts':
return tool_youtube.list_available_transcripts(url=arguments['url'])
elif tool_name == 'summarize_youtube':
# summary_length와 languages 파라미터 전달
summary_length = arguments.get('summary_length', 3000)
lang = arguments.get('language') or arguments.get('languages')
if isinstance(lang, str):
languages = [lang]
elif isinstance(lang, list):
languages = lang
else:
languages = None # 자동 선택
return tool_youtube.summarize_youtube(
url=arguments['url'],
summary_length=summary_length,
languages=languages
)
else:
raise ValueError(f'Unknown tool: {tool_name}')

===FILE:tool_utils.py===
"""
IndieBiz 도구 공통 유틸리티
==========================
여러 도구에서 공용으로 사용하는 함수들
"""

import os

# 공통 출력 경로
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUTS_DIR = os.path.join(BASE_DIR, "outputs")

def markdown_to_html(markdown_text: str, title: str, date_str: str,
doc_type: str = "default") -> str:
"""
Markdown을 HTML로 변환

Args:
markdown_text: 변환할 마크다운 텍스트
title: 문서 제목
date_str: 날짜 문자열
doc_type: 문서 타입 ("newspaper", "magazine", "report", "default")

Returns:
HTML 문자열
"""
import markdown

# Markdown → HTML 변환
html_body = markdown.markdown(
markdown_text,
extensions=['extra', 'nl2br', 'sane_lists', 'toc']
)

# 문서 타입별 설정
type_config = {
"newspaper": {
"class": "newspaper",
"subtitle": f"{date_str} | IndieBiz AI 신문 시스템"
},
"magazine": {
"class": "magazine",
"subtitle": f"{date_str} | IndieBiz Magazine"
},
"report": {
"class": "report",
"subtitle": f"{date_str} | IndieBiz 블로그 인사이트"
},
"default": {
"class": "document",
"subtitle": date_str
}
}

config = type_config.get(doc_type, type_config["default"])

# 공통 스타일
style = """
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}

body {
font-family: 'Malgun Gothic', 'Apple SD Gothic Neo', sans-serif;
line-height: 1.8;
background-color: #f5f5f5;
color: #1a1a1a;
}

.newspaper, .magazine, .report, .document {
max-width: 1200px;
margin: 20px auto;
background: white;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
}

/* 헤더 */
.header {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 40px;
text-align: center;
}

h1 {
font-size: 42px;
font-weight: bold;
margin-bottom: 10px;
}

.subtitle {
font-size: 14px;
opacity: 0.9;
}

/* 본문 */
.content {
padding: 40px;
}

/* 목차 */
.toc {
background: #f9f9f9;
border-left: 4px solid #667eea;
padding: 20px 30px;
margin-bottom: 40px;
}

.toc h2 {
font-size: 18px;
margin-bottom: 15px;
color: #667eea;
border: none;
}

.toc ul {
list-style: none;
}

.toc li {
margin-bottom: 8px;
padding-left: 20px;
position: relative;
}

.toc li::before {
content: '▸';
position: absolute;
left: 0;
color: #667eea;
}

.toc a {
color: #333;
text-decoration: none;
transition: color 0.3s;
}

.toc a:hover {
color: #667eea;
}

/* 섹션 */
h2 {
font-size: 28px;
color: #667eea;
border-bottom: 2px solid #667eea;
padding-bottom: 10px;
margin: 40px 0 20px 0;
}

/* 기사/항목 */
h3 {
font-size: 20px;
color: #333;
margin: 25px 0 10px 0;
line-height: 1.4;
}

p {
margin-bottom: 15px;
line-height: 1.8;
color: #444;
}

strong {
color: #667eea;
}

/* 링크 */
a {
color: #667eea;
text-decoration: none;
border-bottom: 1px solid transparent;
transition: all 0.3s;
}

a:hover {
border-bottom-color: #667eea;
}

/* 버튼형 링크 */
p a {
display: inline-block;
padding: 8px 16px;
background: #f0f0f0;
border-radius: 4px;
border: none;
font-weight: 500;
}

p a:hover {
background: #667eea;
color: white;
}

/* 구분선 */
hr {
border: none;
height: 1px;
background: #e0e0e0;
margin: 30px 0;
}

/* 푸터 */
.footer {
background: #f9f9f9;
border-top: 2px solid #e0e0e0;
padding: 30px 40px;
margin-top: 40px;
}

.footer h2 {
font-size: 18px;
border: none;
margin: 0 0 15px 0;
color: #667eea;
}

.footer ul {
list-style: none;
color: #666;
font-size: 14px;
}

.footer li {
padding: 5px 0;
padding-left: 20px;
position: relative;
}

.footer li::before {
content: '•';
position: absolute;
left: 0;
color: #667eea;
}

/* 반응형 */
@media (max-width: 768px) {
.newspaper, .magazine, .report, .document {
margin: 10px;
}

.header, .content, .footer {
padding: 20px;
}

h1 {
font-size: 28px;
}

h2 {
font-size: 22px;
}

h3 {
font-size: 18px;
}
}
</style>
"""

# 최종 HTML
html = f"""<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{title} - {date_str}</title>
{style}
</head>
<body>
<div class="{config['class']}">
<div class="header">
<h1>{title}</h1>
<div class="subtitle">{config['subtitle']}</div>
</div>
<div class="content">
{html_body}
</div>
</div>
</body>
</html>"""

return html

def save_as_html(content: str, title: str, date_str: str,
filename_prefix: str, doc_type: str = "default") -> dict:
"""
마크다운 콘텐츠를 HTML로 변환하여 저장

Args:
content: 마크다운 콘텐츠
title: 문서 제목
date_str: 날짜 문자열 (예: "2024년 12월 26일")
filename_prefix: 파일명 접두사 (예: "신문", "잡지")
doc_type: 문서 타입

Returns:
{'success': True, 'filepath': '...', 'filename': '...'}
"""
from datetime import datetime

os.makedirs(OUTPUTS_DIR, exist_ok=True)

# 파일명용 날짜
date_filename = datetime.now().strftime("%Y%m%d")

# HTML 변환
html_content = markdown_to_html(content, title, date_str, doc_type)

# 파일 저장
filename = f"{filename_prefix}_{date_filename}.html"
filepath = os.path.join(OUTPUTS_DIR, filename)

with open(filepath, 'w', encoding='utf-8') as f:
f.write(html_content)

return {
'success': True,
'filepath': filepath,
'filename': filename
}

===FILE:tool_youtube.py===
"""
YouTube 다운로드 도구
- 음악 다운로드 (MP3)
- 동영상 정보 조회
- 자막/트랜스크립트 가져오기
- 동영상 요약 (AI 사용)
"""

import os
import shutil
import re
import json
from datetime import datetime
from typing import Optional, List, Dict, Any
# AI 설정 경로
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, "data")

# 시스템 AI 설정 경로 (indiebizOS/data/system_ai_config.json)
INDIEBIZ_DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "..", "..", ".."))
SYSTEM_AI_CONFIG_PATH = os.path.join(INDIEBIZ_DATA_DIR, "system_ai_config.json")
OUTPUTS_DIR = os.path.join(INDIEBIZ_DATA_DIR, "outputs")

def markdown_to_html(content: str, title: str, date_str: str, doc_type: str = "report") -> str:
"""마크다운을 HTML로 변환 (간단 버전)"""
try:
import markdown
html_body = markdown.markdown(content, extensions=['tables', 'fenced_code'])
except ImportError:
html_body = f"<pre>{content}</pre>"

return f"""<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{title}</title>
<style>
body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; line-height: 1.6; }}
h1, h2, h3 {{ color: #333; }}
a {{ color: #0066cc; }}
pre {{ background: #f5f5f5; padding: 10px; overflow-x: auto; }}
code {{ background: #f0f0f0; padding: 2px 5px; border-radius: 3px; }}
</style>
</head>
<body>
<h1>{title}</h1>
<p><em>{date_str}</em></p>
<hr>
{html_body}
</body>
</html>"""

def download_youtube_music(url: str, filename: str = "output.mp3") -> dict:
"""YouTube에서 음악을 MP3로 다운로드"""
try:
import yt_dlp
except ImportError:
return {
'success': False,
'message': 'yt_dlp 패키지가 설치되지 않았습니다. pip install yt-dlp 실행 필요'
}

try:
# 동적으로 Desktop 경로 설정 (크로스 플랫폼 지원)
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
if not os.path.isabs(filename):
filename = os.path.join(desktop_path, filename)

if not filename.endswith('.mp3'):
filename += '.mp3'

# FFmpeg 경로 찾기 (크로스 플랫폼)
ffmpeg_path = shutil.which("ffmpeg")
if not ffmpeg_path:
# 일반적인 설치 경로들 확인
common_paths = [
"/opt/homebrew/bin/ffmpeg", # macOS (Apple Silicon)
"/usr/local/bin/ffmpeg", # macOS (Intel) / Linux
"/usr/bin/ffmpeg", # Linux
]
for path in common_paths:
if os.path.isfile(path):
ffmpeg_path = path
break

if not ffmpeg_path or not os.path.isfile(ffmpeg_path):
return {
'success': False,
'message': 'FFmpeg를 찾을 수 없습니다. FFmpeg를 설치해주세요. (brew install ffmpeg)'
}

print(f"[YouTube] 다운로드 시작: {url}")
print(f"[YouTube] 저장 위치: {filename}")

# 진행 상황 표시
def progress_hook(d):
if d['status'] == 'downloading':
print(f"[YouTube] 다운로드 중... {d.get('_percent_str', '?')}%")
elif d['status'] == 'finished':
print(f"[YouTube] 다운로드 완료, MP3 변환 중...")

ydl_opts = {
'format': 'bestaudio/best',
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': '320',
}],
'outtmpl': filename.rsplit('.mp3', 1)[0],
'ffmpeg_location': ffmpeg_path,
'quiet': False, # 진행 상황 표시
'no_warnings': False,
'noprogress': False,
'progress_hooks': [progress_hook],
'noplaylist': True, # 플레이리스트 무시, 단일 비디오만 다운로드
'extract_flat': False,
}

with yt_dlp.YoutubeDL(ydl_opts) as ydl:
print(f"[YouTube] 비디오 정보 가져오는 중...")
info = ydl.extract_info(url, download=False)
title = info.get('title', 'Unknown')
duration = info.get('duration', 0)

print(f"[YouTube] 제목: {title}")
print(f"[YouTube] 길이: {duration}초")
print(f"[YouTube] 다운로드 시작...")

ydl.download([url])

print(f"[YouTube] 완료! 파일: {filename}")

return {
'success': True,
'file_path': filename,
'title': title,
'duration': duration,
'message': f'다운로드 완료: {title} ({duration}초)'
}
except Exception as e:
print(f"[YouTube] 오류: {str(e)}")
return {
'success': False,
'message': f'다운로드 실패: {str(e)}'
}

def format_timestamp(seconds: float) -> str:
"""초를 HH:MM:SS 또는 MM:SS 형식으로 변환합니다."""
hours = int(seconds // 3600)
minutes = int((seconds % 3600) // 60)
secs = int(seconds % 60)

if hours > 0:
return f"{hours:02d}:{minutes:02d}:{secs:02d}"
return f"{minutes:02d}:{secs:02d}"

def merge_transcript_segments(segments: List[dict], max_duration: float = 60.0) -> List[dict]:
"""자막 세그먼트를 병합하여 더 읽기 쉬운 형태로 만듭니다.

Args:
segments: 자막 세그먼트 리스트 (각 세그먼트는 start, duration, text 포함)
max_duration: 병합할 최대 시간 간격 (초, 기본 60초)

Returns:
병합된 자막 세그먼트 리스트
"""
if not segments:
return []

merged = []
current_segment = {
'start': segments[0]['start'],
'text': segments[0]['text'],
'duration': segments[0].get('duration', 0)
}

for segment in segments[1:]:
if segment['start'] - current_segment['start'] < max_duration:
current_segment['text'] += ' ' + segment['text']
current_segment['duration'] = segment['start'] + segment.get('duration', 0) - current_segment['start']
else:
merged.append(current_segment)
current_segment = {
'start': segment['start'],
'text': segment['text'],
'duration': segment.get('duration', 0)
}

merged.append(current_segment)
return merged

def get_youtube_info(url: str) -> dict:
"""YouTube 동영상 정보 조회"""
try:
import yt_dlp
except ImportError:
return {'success': False, 'message': 'yt_dlp 패키지 없음'}

try:
with yt_dlp.YoutubeDL({'quiet': True, 'no_warnings': True}) as ydl:
info = ydl.extract_info(url, download=False)
return {
'success': True,
'title': info.get('title', 'Unknown'),
'duration': info.get('duration', 0),
'uploader': info.get('uploader', 'Unknown'),
'view_count': info.get('view_count', 0),
}
except Exception as e:
return {'success': False, 'message': f'실패: {str(e)}'}

def extract_video_id(url: str) -> str:
"""YouTube URL에서 video_id 추출"""
# 이미 ID 형식인 경우
if re.match(r'^[a-zA-Z0-9_-]{11}$', url):
return url

patterns = [
r'(?:v=|/v/|youtu\.be/)([a-zA-Z0-9_-]{11})',
r'(?:embed/)([a-zA-Z0-9_-]{11})',
r'youtube\.com\/shorts\/([a-zA-Z0-9_-]{11})',
]
for pattern in patterns:
match = re.search(pattern, url)
if match:
return match.group(1)
return None

def list_available_transcripts(url: str) -> dict:
"""YouTube 동영상에서 사용 가능한 자막 언어 목록을 조회합니다.

Args:
url: YouTube URL 또는 video_id

Returns:
dict: {
'success': bool,
'video_id': str,
'manual_transcripts': list, # 수동 생성 자막 목록
'auto_transcripts': list, # 자동 생성 자막 목록
'message': str
}
"""
try:
from youtube_transcript_api import YouTubeTranscriptApi
except ImportError:
return {
'success': False,
'message': 'youtube-transcript-api 패키지가 필요합니다. pip install youtube-transcript-api'
}

video_id = extract_video_id(url)
if not video_id:
return {
'success': False,
'message': f'올바른 YouTube URL이 아닙니다: {url}'
}

try:
ytt_api = YouTubeTranscriptApi()
transcript_list = ytt_api.list(video_id)

manual_transcripts = []
auto_transcripts = []

for t in transcript_list:
info = {
'language': t.language,
'language_code': t.language_code,
'is_translatable': t.is_translatable
}
if t.is_generated:
auto_transcripts.append(info)
else:
manual_transcripts.append(info)

return {
'success': True,
'video_id': video_id,
'manual_transcripts': manual_transcripts,
'auto_transcripts': auto_transcripts,
'message': f'자막 언어 목록 조회 완료. 수동: {len(manual_transcripts)}개, 자동: {len(auto_transcripts)}개'
}

except Exception as e:
return {
'success': False,
'message': f'자막 목록 조회 실패: {str(e)}'
}

def get_youtube_transcript(
url: str,
languages: list = None,
include_timestamps: bool = False,
merge_segments: bool = False,
max_length: Optional[int] = None
) -> dict:
"""
YouTube 동영상의 자막/트랜스크립트를 가져옵니다.

Args:
url: YouTube URL 또는 video_id
languages: 선호 언어 목록 (예: ['ko', 'en']). None이면 자동 선택
include_timestamps: True면 타임스탬프 포함 형식으로 반환
merge_segments: True면 짧은 세그먼트를 60초 단위로 병합
max_length: 반환할 자막의 최대 문자 수 (None이면 제한 없음)

Returns:
dict: {
'success': bool,
'transcript': str, # 전체 자막 텍스트
'formatted_transcript': str, # 포맷팅된 자막 (타임스탬프 포함 시)
'segments': list, # 타임스탬프 포함 세그먼트
'language': str, # 사용된 언어
'title': str, # 영상 제목
'duration': int, # 영상 길이 (초)
'message': str
}
"""
try:
from youtube_transcript_api import YouTubeTranscriptApi
except ImportError:
return {
'success': False,
'message': 'youtube-transcript-api 패키지가 필요합니다. pip install youtube-transcript-api'
}

# video_id 추출
video_id = extract_video_id(url)
if not video_id:
return {
'success': False,
'message': f'올바른 YouTube URL이 아닙니다: {url}'
}

# 영상 정보 가져오기 (선택적)
video_info = get_youtube_info(url)
title = video_info.get('title', 'Unknown') if video_info.get('success') else 'Unknown'
duration = video_info.get('duration', 0) if video_info.get('success') else 0

try:
# 언어 우선순위 설정
if languages is None:
languages = ['ko', 'en', 'ja', 'zh-Hans', 'zh-Hant']

# youtube-transcript-api 1.2.x 새로운 API 사용
ytt_api = YouTubeTranscriptApi()

transcript_data = None
used_language = None

# 선호 언어 순서대로 시도
for lang in languages:
try:
transcript_data = ytt_api.fetch(video_id, languages=[lang])
used_language = lang
break
except Exception:
continue

# 선호 언어로 못 찾으면 아무 자막이나
if transcript_data is None:
try:
transcript_data = ytt_api.fetch(video_id)
used_language = 'auto'
except Exception as e:
return {
'success': False,
'message': f'자막을 찾을 수 없습니다: {str(e)}'
}

if not transcript_data:
return {
'success': False,
'message': '사용 가능한 자막이 없습니다.'
}

# 타임스탬프 포함 세그먼트
segments = [
{
'start': segment.start,
'duration': segment.duration,
'text': segment.text
}
for segment in transcript_data
]

# 세그먼트 병합 옵션 적용
if merge_segments:
segments = merge_transcript_segments(segments)

# 전체 텍스트로 합치기
full_text = ' '.join([s['text'] for s in segments])
full_text = re.sub(r'\s+', ' ', full_text).strip()

# 최대 길이 제한 적용
if max_length and len(full_text) > max_length:
full_text = full_text[:max_length] + "... (자막이 잘렸습니다)"

# 타임스탬프 포함 포맷팅
formatted_transcript = None
if include_timestamps:
formatted_lines = []
for segment in segments:
timestamp = format_timestamp(segment['start'])
text = segment['text'].strip()
formatted_lines.append(f"[{timestamp}] {text}")
formatted_transcript = '\n'.join(formatted_lines)

return {
'success': True,
'transcript': full_text,
'formatted_transcript': formatted_transcript,
'segments': segments,
'language': used_language,
'title': title,
'duration': duration,
'video_id': video_id,
'message': f'자막을 성공적으로 가져왔습니다. (언어: {used_language}, 세그먼트: {len(segments)}개)'
}

except Exception as e:
return {
'success': False,
'message': f'자막 가져오기 실패: {str(e)}'
}

def load_system_ai_config() -> dict:
"""시스템 AI 설정 로드"""
if os.path.exists(SYSTEM_AI_CONFIG_PATH):
try:
with open(SYSTEM_AI_CONFIG_PATH, 'r', encoding='utf-8') as f:
return json.load(f)
except:
pass
return {
"provider": "google",
"model": "gemini-2.0-flash",
"apiKey": ""
}

def get_summary_ai_client():
"""요약용 AI 클라이언트 반환 (시스템 AI 설정 사용)"""
config = load_system_ai_config()

provider = config.get("provider", "google")
model = config.get("model", "gemini-2.0-flash")
api_key = config.get("apiKey") or config.get("api_key", "")

# provider 이름 정규화
if provider in ["google", "gemini"]:
from google import genai
client = genai.Client(api_key=api_key)
return client, "gemini", model
elif provider == "openai":
import openai
client = openai.OpenAI(api_key=api_key)
return client, "openai", model
elif provider == "anthropic":
import anthropic
client = anthropic.Anthropic(api_key=api_key)
return client, "anthropic", model
else:
raise ValueError(f"Unknown provider: {provider}")

def summarize_youtube(
url: str,
summary_length: int = 3000,
languages: list = None
) -> Dict[str, Any]:
"""
YouTube 동영상을 AI로 요약하여 HTML 파일로 저장합니다.

Args:
url: YouTube URL 또는 video_id
summary_length: 요약 길이 (기본 3000자)
languages: 선호 언어 목록 (예: ['ko', 'en']). None이면 자동 선택

Returns:
dict: {
'success': bool,
'file_path': str, # 생성된 HTML 파일 경로
'title': str, # 영상 제목
'duration': int, # 영상 길이 (초)
'message': str
}
"""
print(f"\n📺 YouTube 영상 요약 시작: {url}")

# 1. 자막 가져오기
print("[1/3] 자막 가져오는 중...")
transcript_result = get_youtube_transcript(url, languages=languages)

if not transcript_result.get('success'):
return {
'success': False,
'message': f"자막 가져오기 실패: {transcript_result.get('message')}"
}

transcript = transcript_result.get('transcript', '')
title = transcript_result.get('title', 'Unknown')
duration = transcript_result.get('duration', 0)
video_id = transcript_result.get('video_id', '')
language = transcript_result.get('language', 'auto')

print(f" ✓ 자막 가져오기 완료 (언어: {language}, {len(transcript)}자)")

# 2. AI로 요약 생성
print("[2/3] AI 요약 생성 중...")

summary_prompt = f"""다음은 YouTube 동영상의 자막입니다. 이 내용을 {summary_length}자 내외로 상세하게 요약해주세요.

## 요약 형식

### 영상 개요
- 영상의 핵심 주제와 목적

### 주요 내용
- 영상에서 다루는 핵심 포인트들을 구조적으로 정리
- 중요한 개념, 주장, 근거 포함
- 소제목을 사용해 구분

### 핵심 인사이트
- 이 영상에서 얻을 수 있는 가장 중요한 통찰 3가지

### 결론
- 영상의 결론 및 시사점

톤: 정보 전달에 충실하되 읽기 쉽게
분량: 약 {summary_length}자

=== 영상 정보 ===
제목: {title}
길이: {duration // 60}분 {duration % 60}초

=== 자막 내용 ===
{transcript[:50000]}
"""

try:
ai_result = get_summary_ai_client()

if ai_result[1] == "gemini":
client, _, model_name = ai_result
response = client.models.generate_content(
model=model_name,
contents=summary_prompt
)
summary_content = response.text
elif ai_result[1] == "openai":
client, _, model_name = ai_result
response = client.chat.completions.create(
model=model_name,
messages=[{"role": "user", "content": summary_prompt}]
)
summary_content = response.choices[0].message.content
elif ai_result[1] == "anthropic":
client, _, model_name = ai_result
response = client.messages.create(
model=model_name,
max_tokens=8192,
messages=[{"role": "user", "content": summary_prompt}]
)
summary_content = response.content[0].text

print(f" ✓ AI 요약 완료 ({len(summary_content)}자)")

except Exception as ai_err:
return {
'success': False,
'message': f"AI 요약 실패: {str(ai_err)}"
}

# 3. HTML 파일로 저장
print("[3/3] HTML 파일 생성 중...")

timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
today_str = datetime.now().strftime("%Y년 %m월 %d일")

# 제목에서 파일명으로 쓸 수 없는 문자 제거
safe_title = re.sub(r'[^\w가-힣\s-]', '', title)[:30].strip()

markdown_content = f"""# {title}

**영상 링크**: [YouTube에서 보기](https://youtube.com/watch?v={video_id})
**영상 길이**: {duration // 60}분 {duration % 60}초
**요약 일시**: {today_str}
**요약 길이**: 약 {summary_length}자

---

{summary_content}

---

## 📊 요약 정보

- **원본 자막 길이**: {len(transcript)}자
- **요약 길이**: {len(summary_content)}자
- **요약 언어**: {language}
- **생성 시각**: {datetime.now().strftime('%Y년 %m월 %d일 %H시 %M분')}
"""

# HTML 변환 및 저장
os.makedirs(OUTPUTS_DIR, exist_ok=True)

html_content = markdown_to_html(markdown_content, f"YouTube 요약: {title}", today_str, doc_type="report")
html_filename = f"youtube_summary_{safe_title}_{timestamp}.html"
html_filepath = os.path.join(OUTPUTS_DIR, html_filename)

with open(html_filepath, 'w', encoding='utf-8') as f:
f.write(html_content)

print(f"💾 HTML 저장: {html_filename}")
print(f"✅ YouTube 요약 완료!\n")

return {
'success': True,
'file_path': html_filepath,
'title': title,
'duration': duration,
'summary_length': len(summary_content),
'message': f'YouTube 영상 요약이 완료되었습니다. 파일: {html_filepath}'
}

# 도구 정의
YOUTUBE_TOOLS = [
{
"name": "download_youtube_music",
"description": "YouTube에서 음악을 MP3로 다운로드합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL"},
"filename": {"type": "string", "description": "파일명"}
},
"required": ["url"]
}
},
{
"name": "get_youtube_info",
"description": "YouTube 동영상 정보를 조회합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL"}
},
"required": ["url"]
}
},
{
"name": "get_youtube_transcript",
"description": "YouTube 동영상의 자막/트랜스크립트를 가져옵니다. 영상 내용을 텍스트로 추출할 때 사용합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL 또는 video_id"},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 언어 코드 목록 (예: ['ko', 'en']). 생략시 자동 선택"
},
"include_timestamps": {
"type": "boolean",
"description": "True면 [MM:SS] 형식의 타임스탬프 포함. 기본값: False"
},
"merge_segments": {
"type": "boolean",
"description": "True면 짧은 자막을 60초 단위로 병합하여 가독성 향상. 기본값: False"
},
"max_length": {
"type": "integer",
"description": "반환할 자막의 최대 문자 수. 요약용으로 사용 시 유용. 생략시 제한 없음"
}
},
"required": ["url"]
}
},
{
"name": "list_available_transcripts",
"description": "YouTube 동영상에서 사용 가능한 자막 언어 목록을 조회합니다. 어떤 언어 자막이 있는지 미리 확인할 때 유용합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL 또는 video_id"}
},
"required": ["url"]
}
},
{
"name": "summarize_youtube",
"description": "YouTube 동영상을 AI로 요약하여 HTML 파일로 저장합니다. 자막을 가져와서 AI가 지정된 길이로 요약하고, 결과를 HTML 파일로 저장한 뒤 파일 경로를 반환합니다.",
"uses_ai": True,
"ai_config_key": "youtube",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL 또는 video_id"},
"summary_length": {
"type": "integer",
"description": "요약 길이 (기본 3000자). 예: 1000, 2000, 3000, 5000"
},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 언어 코드 목록 (예: ['ko', 'en']). 생략시 자동 선택"
}
},
"required": ["url"]
}
}
]

===FILE:README.md===
# YouTube 도구

## 목적

에이전트가 YouTube 동영상을 다루는 능력을 제공합니다.
음악 다운로드, 정보 조회, 자막 추출, AI 요약 등을 할 수 있습니다.

## 이 도구가 제공하는 것

- **음악 다운로드**: YouTube 영상에서 MP3 추출
- **정보 조회**: 제목, 길이, 조회수, 설명 등
- **자막 추출**: 자동 생성 또는 수동 자막 텍스트화
- **AI 요약**: 자막 기반으로 영상 내용 요약

## 설치 시 필요한 변경사항

### 1. 도구 함수 구현

에이전트가 호출할 수 있는 도구 함수들을 구현해야 합니다.

**download_youtube_music(url, output_path)**
- YouTube URL에서 음악만 추출
- MP3 또는 M4A 형식으로 저장
- 파일 경로 반환

**get_youtube_info(url)**
- 영상 메타데이터 조회
- 제목, 채널, 길이, 조회수, 설명 등 반환

**get_youtube_transcript(url, language)**
- 자막 텍스트 추출
- 언어 지정 가능 (ko, en 등)
- 시간 정보 포함/제외 선택

**list_available_transcripts(url)**
- 해당 영상에서 사용 가능한 자막 언어 목록

**summarize_youtube(url, ai_config)**
- 자막을 가져와서 AI로 요약
- 결과를 HTML 파일로 저장

### 2. 도구 정의

AI가 도구를 인식할 수 있도록 정의해야 합니다.

```json
{
"name": "download_youtube_music",
"description": "YouTube 영상에서 음악을 MP3로 다운로드합니다",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL"},
"output_path": {"type": "string", "description": "저장 경로 (선택)"}
},
"required": ["url"]
}
}
```

### 3. 에이전트 연동

설치된 도구를 에이전트가 사용할 수 있어야 합니다.

- 프로젝트 설정에서 이 도구를 에이전트에 배정
- AI 호출 시 도구 정의 포함
- tool_use 응답 처리

### 4. 출력 관리

다운로드된 파일과 생성된 결과를 관리해야 합니다.

- 기본 저장 경로 설정
- 파일명 중복 처리
- 용량 관리 (선택)

## 외부 의존성

이 도구는 외부 프로그램이 필요합니다.

**yt-dlp**: YouTube 다운로더
```bash
pip install yt-dlp
```

**ffmpeg**: 오디오 변환
```bash
# macOS
brew install ffmpeg

# Ubuntu
sudo apt install ffmpeg

# Windows
# ffmpeg.org에서 다운로드 후 PATH에 추가
```

**youtube-transcript-api**: 자막 추출
```bash
pip install youtube-transcript-api
```

## 참고 구현

이 폴더의 `tool_youtube.py`는 Python 기반 구현 예시입니다.

```
tool_youtube.py
├── download_youtube_music()
├── get_youtube_info()
├── get_youtube_transcript()
├── list_available_transcripts()
├── summarize_youtube()
└── YOUTUBE_TOOLS (도구 정의)
```

이 코드를 그대로 사용하지 말고, 현재 시스템에 맞게 구현하세요.

## 법적 고려사항

- 저작권이 있는 콘텐츠 다운로드 시 주의
- 개인 사용 목적으로만 사용 권장
- YouTube 이용약관 확인

## 설치 완료 확인

- [ ] 에이전트가 도구를 호출할 수 있음
- [ ] YouTube URL에서 음악 다운로드 가능
- [ ] 영상 정보 조회 가능
- [ ] 자막 추출 가능
- [ ] AI 요약 생성 가능

===PACKAGE_END===

#indiebizOS-package

📦 IndieBiz OS 도구 패키지 이름: Youtube 설명: ...

2026-01-22T02:19:53Z

📦 IndieBiz OS 도구 패키지

이름: Youtube
설명: 에이전트가 YouTube 동영상을 다루는 능력을 제공합니다. 음악 다운로드, 정보 조회, 자막 추출, AI 요약 등을 할 수 있습니다. | 제공 도구: get_youtube_info, get_youtube_transcript, list_available_transcripts, summarize_youtube, download_youtube_music
버전: 1.0.0

설치 방법:
[기능 구현이 목적입니다. 코드가 똑같을 필요 없습니다.]
YouTube 영상의 정보 조회, 자막 추출, MP3 다운로드 및 AI 요약을 제공하는 패키지입니다.

도구:
- get_youtube_info: 제목, 채널, 조회수 등 메타데이터 수집. 입력: url(string). 출력: dict.
- get_youtube_transcript: 영상 자막 추출. 입력: url(string), languages(array), include_timestamps(bool). 출력: string. (타임스탬프 및 세그먼트 병합 지원)
- list_available_transcripts: 사용 가능한 자막 언어 및 자동생성 여부 확인. 입력: url(string). 출력: list.
- summarize_youtube: 자막 기반 AI 요약 및 HTML 파일 생성. 입력: url(string), summary_length(int). 출력: string(결과 메시지).
- download_youtube_music: 영상을 MP3로 변환하여 다운로드. 입력: url(string), filename(string). 출력: dict(성공여부).

의존성: pip install yt-dlp youtube-transcript-api markdown
시스템 요구사항: FFmpeg 설치 필수 (MP3 변환용)

✍️ made by kukjin

#indiebizOS-package

📦 IndieBiz OS 도구 패키지 이름: Shopping Assistant ...

2026-01-22T02:18:27Z

📦 IndieBiz OS 도구 패키지

이름: Shopping Assistant
설명: 제공 도구: search_shopping
버전: 1.0.0

설치 방법:
[기능 구현이 목적입니다. 코드가 똑같을 필요 없습니다.]
네이버 쇼핑 API와 다나와 웹 크롤링을 결합하여 통합 상품 검색 기능을 제공하는 패키지입니다.
도구:
- search_shopping(): 지정된 사이트에서 상품 정보를 검색. 입력: query(검색어), site(naver/danawa/all), display(검색 결과 수). 출력: {items: [{name, price, mall, link, image, category, site}], total}. (네이버는 공식 검색 API를 사용하며, 다나와는 Playwright 등 헤드리스 브라우저를 이용한 동적 크롤링으로 구현)
의존성: pip install requests playwright, npx playwright install
준비사항: 네이버 검색 API 사용을 위한 Client ID 및 Secret 환경변수 설정 필요

✍️ made by kukjin

#indiebizOS-package