[인덱싱] 코드를 검색 가능한 형태로 변환
Git Pull → 파일 수집 → AST 파싱 → 청킹 → 임베딩 → DB 저장

[검색] 자연어 질문에 맞는 코드 찾기
쿼리 → 동의어 확장 → 하이브리드 검색 → 점수 합산 → 결과 반환

# 의미 있는 코드 단위로 분리하기 위한 노드 타입 정의
CHUNK_NODE_TYPES = [
    "function_declaration",      # function foo() {}
    "arrow_function",            # const foo = () => {}
    "export_statement",          # export const Component
    "interface_declaration",     # interface Props {}
    "type_alias_declaration",    # type MyType = ...
    "class_declaration",         # class MyClass {}
]

def chunk_file_with_ast(file_path, repo_name):
    # 파일 확장자에 따라 적절한 파서 선택
    if file_path.suffix in [".tsx", ".jsx"]:
        parser = tsx_parser
    else:
        parser = ts_parser
    
    # 파일 내용을 바이트로 읽어서 파싱
    content = file_path.read_bytes()
    tree = parser.parse(content)
    
    chunks = []
    
    # AST를 순회하며 청킹 대상 노드 수집
    def collect_declarations(node, depth=0):
        if node.type in CHUNK_NODE_TYPES:
            chunk = {
                "content": node.text.decode("utf-8"),
                "node_type": node.type,
                "node_name": extract_node_name(node),
                "start_line": node.start_point[0] + 1,
                "end_line": node.end_point[0] + 1,
                "file_path": str(file_path),
                "repo": repo_name
            }
            chunks.append(chunk)
        
        # 깊이 2까지만 탐색 (너무 깊이 들어가면 불필요한 노드까지 수집)
        if depth < 2:
            for child in node.children:
                collect_declarations(child, depth + 1)
    
    collect_declarations(tree.root_node)
    return chunks

def search_code(query, top_k=5, repo_filter=None):
    # 1. 쿼리 전처리 - 동의어 확장
    expanded_query = expand_query_with_synonyms(query)
    
    # 2. 벡터 검색 - 의미 기반 유사도
    query_embedding = get_embedding(query)
    vector_results = collection.query(
        query_embeddings=[query_embedding],
        n_results=top_k * 3,  # 후보를 넉넉하게 가져옴
        where={"repo": repo_filter} if repo_filter else None
    )
    
    # 벡터 거리를 점수로 변환 (거리가 가까울수록 높은 점수)
    for i, distance in enumerate(vector_results["distances"][0]):
        vector_scores[i] = max(0, min(1, 1 - distance / 10))
    
    # 3. BM25 키워드 검색 - 정확한 토큰 매칭
    keyword_scores = bm25_search(expanded_query, candidates)
    
    # 4. 패턴 매칭 - 특수 패턴 보너스
    pattern_scores = pattern_search(query, candidates)
    
    # 5. 최종 점수 계산
    final_results = []
    for i, candidate in enumerate(candidates):
        final_score = (
            vector_scores.get(i, 0) * 0.5 +
            keyword_scores.get(i, 0) * 0.3 +
            pattern_scores.get(i, 0) * 0.2
        )
        candidate["score"] = final_score
        final_results.append(candidate)
    
    # 점수 순으로 정렬 후 상위 k개 반환
    final_results.sort(key=lambda x: -x["score"])
    return final_results[:top_k]

def tokenize(text):
    """텍스트를 토큰으로 분리"""
    # 영문 식별자와 한글을 각각 토큰으로 분리
    tokens = re.findall(r'[a-zA-Z_][a-zA-Z0-9_]*|[가-힣]+', text.lower())
    return tokens
 
def calculate_bm25_score(query_tokens, doc_tokens, avg_doc_len, k1=1.5, b=0.75):
    """BM25 점수 계산"""
    doc_len = len(doc_tokens)
    doc_freq = Counter(doc_tokens)
    score = 0
    
    for token in query_tokens:
        if token in doc_freq:
            tf = doc_freq[token]
            # BM25 공식 적용
            numerator = tf * (k1 + 1)
            denominator = tf + k1 * (1 - b + b * (doc_len / avg_doc_len))
            score += numerator / denominator
    
    return score
 
def bm25_search(query, candidates):
    """모든 후보에 대해 BM25 점수 계산"""
    query_tokens = tokenize(query)
    
    # 평균 문서 길이 계산
    all_doc_lengths = [len(tokenize(c["content"])) for c in candidates]
    avg_doc_len = sum(all_doc_lengths) / len(all_doc_lengths)
    
    scores = {}
    for i, candidate in enumerate(candidates):
        doc_tokens = tokenize(candidate["content"])
        scores[i] = calculate_bm25_score(query_tokens, doc_tokens, avg_doc_len)
    
    # 정규화 (0~1 범위로)
    max_score = max(scores.values()) if scores else 1
    return {i: s / max_score for i, s in scores.items()}

# 도메인 특화 동의어 사전
SYNONYM_DICT = {
    # 팀 용어 -> 실제 코드에서 사용되는 키워드들
    "브릿지": ["bridge", "postMessage", "native"],
    "디자인시스템": ["design-system", "Button", "Input", "Modal"],
    "인증": ["auth", "login", "signIn", "token"],
    "예약": ["reservation", "booking", "schedule"],
}
 
# 패턴 기반 검색을 위한 정규식
PATTERN_KEYWORDS = {
    "훅": [r"use[A-Z]\w+"],           # useAuth, useState 등
    "API": [r"fetch\(", r"axios"],    # API 호출 패턴
    "컴포넌트": [r"export.*function", r"export.*const.*=.*\("], 
}
 
def expand_query_with_synonyms(query):
    """쿼리를 동의어로 확장"""
    expanded_terms = query.split()
    
    for key, synonyms in SYNONYM_DICT.items():
        if key in query:
            expanded_terms.extend(synonyms)
    
    # 중복 제거 후 반환
    return " ".join(list(dict.fromkeys(expanded_terms)))

# 임베딩 캐시 (LRU 방식)
_embedding_cache = {}
MAX_CACHE_SIZE = 100
 
def get_embedding(text):
    """텍스트의 임베딩 벡터를 반환 (캐시 적용)"""
    # 캐시 키는 텍스트의 앞 500자로 제한
    cache_key = text[:500]
    
    # 캐시 히트
    if cache_key in _embedding_cache:
        return _embedding_cache[cache_key]
    
    # 캐시가 가득 차면 오래된 항목 삭제
    if len(_embedding_cache) >= MAX_CACHE_SIZE:
        # 앞쪽 절반 삭제 (간단한 LRU 구현)
        keys_to_remove = list(_embedding_cache.keys())[:MAX_CACHE_SIZE // 2]
        for key in keys_to_remove:
            del _embedding_cache[key]
    
    # OpenAI API 호출
    response = openai_client.embeddings.create(
        input=[text],
        model="text-embedding-3-large"
    )
    embedding = response.data[0].embedding
    
    # 캐시에 저장
    _embedding_cache[cache_key] = embedding
    return embedding

from fastmcp import FastMCP
 
mcp = FastMCP("web-butler")
 
@mcp.tool()
def search_web_code(
    query: str, 
    repo: str = None, 
    node_type: str = None, 
    top_k: int = 5
) -> str:
    """
    웹팀 코드베이스를 자연어로 검색합니다.
    
    Args:
        query: 검색 쿼리 (예: "Button 컴포넌트 사용법")
        repo: 특정 레포로 필터링 (선택사항)
        node_type: 노드 타입 필터 - function, component 등 (선택사항)
        top_k: 반환할 결과 수 (기본값: 5)
    
    Returns:
        검색된 코드 조각들을 마크다운 형식으로 반환
    """
    results = search_code(query, top_k, repo, node_type)
    
    # 마크다운 형식으로 결과 포매팅
    output = f"## '{query}' 검색 결과\n\n"
    
    for i, result in enumerate(results, 1):
        output += f"### {i}. {result['node_name']} ({result['node_type']})\n"
        output += f"**파일**: `{result['file_path']}`\n"
        output += f"**라인**: {result['start_line']}-{result['end_line']}\n\n"
        output += f"```typescript\n{result['content']}\n```\n\n"
    
    return output
 
@mcp.tool()
def ask_web_code(question: str, top_k: int = 5) -> str:
    """
    코드베이스에 대해 자연어로 질문합니다.
    관련 코드를 검색하고 컨텍스트와 함께 반환합니다.
    
    Args:
        question: 질문 (예: "로그인 로직이 어떻게 구현되어 있어?")
        top_k: 참고할 코드 조각 수 (기본값: 5)
    
    Returns:
        관련 코드와 함께 질문에 답변할 수 있는 컨텍스트
    """
    results = search_code(question, top_k)
    
    context = "다음 코드를 참고하여 질문에 답변해주세요:\n\n"
    for result in results:
        context += f"### {result['file_path']}\n"
        context += f"```typescript\n{result['content']}\n```\n\n"
    
    context += f"\n**질문**: {question}"
    return context
 
# 서버 실행
if __name__ == "__main__":
    mcp.run()

"웹에서 결제 API 호출하는 부분이랑 서버 엔드포인트 둘 다 보여줘"