codebuff-agent 2.1.74__py3-none-any.whl

codebuff_core/legacy_paths.py

@@ -0,0 +1,69 @@
+"""hdsp_agent → codebuff 리네이밍(이슈 #87) 하위호환 경로 해석.
+
+사용자 홈에 이미 쓰여 있는 것들 — Qdrant 인덱스, API 키가 든 설정 파일, 세션 —
+은 이름이 바뀌어도 그대로 읽혀야 한다. 새 경로가 없고 옛 경로가 있으면 옛 경로를
+쓴다. **경로를 옮기거나 지우지 않는다** — 기존 사용자는 계속 옛 트리를 읽고 쓰고,
+새 사용자만 새 트리를 쓴다. 마이그레이션은 이 코드가 할 일이 아니다.
+
+**판정은 프로세스당 한 번이다**(`_decide` 의 `lru_cache`). 호출마다 다시 재면 같은
+프로세스 안에서 답이 **뒤집힌다** — 누군가 `os.makedirs` 로 새 경로를 만드는 순간
+그 뒤의 호출이 빈 새 디렉터리를 가리키고, 기존 인덱스는 살아 있는데 안 보이게
+된다. 실제로 `rag_admin_handler` 가 그 `makedirs` 를 한다.
+
+**`CODEBUFF_HOME` 이 있으면 상태를 그 아래에 둔다**(이슈 #116). 워크트리에서 띄운
+JupyterLab 이 주 저장소의 서버와 Qdrant 락·세션을 나눠 쓰지 않게 하려는 것이라
+(`scripts/jl_env.sh`), 그때는 옛 경로 폴백을 하지 않는다 — 폴백하면 워크트리 서버가
+사람의 `~/.hdsp_agent` 를 열어 격리가 깨진다.
+"""
+
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+
+LEGACY_HOME_DIR = "~/.hdsp_agent"
+HOME_DIR = "~/.codebuff"
+HOME_ENV = "CODEBUFF_HOME"
+
+
+def override_home() -> Optional[Path]:
+    """`CODEBUFF_HOME` 이 설정돼 있으면 그 경로, 아니면 None."""
+    value = os.environ.get(HOME_ENV)
+    return Path(value) if value else None
+
+
+@lru_cache(maxsize=None)
+def _decide(new_path: str, legacy_path: str) -> Path:
+    new_p = Path(os.path.expanduser(new_path))
+    legacy_p = Path(os.path.expanduser(legacy_path))
+    if not new_p.exists() and legacy_p.exists():
+        return legacy_p
+    return new_p
+
+
+def resolve(new_path, legacy_path) -> Path:
+    """새 경로가 없고 옛 경로가 있으면 옛 경로를, 아니면 새 경로를 돌려준다."""
+    return _decide(str(new_path), str(legacy_path))
+
+
+def resolve_home(subpath: str) -> Path:
+    """`~/.codebuff/<subpath>` 를 옛 `~/.hdsp_agent/<subpath>` 폴백과 함께 해석한다."""
+    home = override_home()
+    if home is not None:
+        return home / subpath
+    return resolve(f"{HOME_DIR}/{subpath}", f"{LEGACY_HOME_DIR}/{subpath}")
+
+
+def resolve_jupyter_config(name: str, legacy_name: str) -> Path:
+    """`~/.jupyter/<name>` 을 옛 이름 폴백과 함께 해석한다.
+
+    이 함수로 찾는 것은 세션·검색 이력 같은 상태 파일이라 `CODEBUFF_HOME` 을 따른다.
+    API 키가 든 설정 파일은 이 함수를 거치지 않으므로 워크트리에서도 공유된다.
+    """
+    home = override_home()
+    if home is not None:
+        return home / name
+    jupyter_dir = Path(os.path.expanduser("~/.jupyter"))
+    return resolve(jupyter_dir / name, jupyter_dir / legacy_name)

codebuff_core/llm/__init__.py

@@ -0,0 +1,13 @@
+"""
+Codebuff Core - LLM Service
+
+Multi-provider LLM interaction abstraction layer.
+"""
+
+from .service import LLMService, call_llm, call_llm_stream
+
+__all__ = [
+    "LLMService",
+    "call_llm",
+    "call_llm_stream",
+]

codebuff_core/llm/service.py

@@ -0,0 +1,407 @@
+"""
+LLM 서비스 - vLLM (OpenAI 호환) 프로바이더와의 상호작용 처리
+
+vLLM 프로바이더를 통해 OpenAI 호환 API를 지원합니다.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import asyncio
+from typing import Dict, Any, Optional
+from contextlib import asynccontextmanager
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MAX_OUTPUT_TOKENS = 4096
+_MAX_CONTINUATIONS = 3
+
+
+def _messages(full_prompt: str, system_prompt: Optional[str]) -> list:
+    """system 은 부르는 쪽이 줄 때만 싣는다 (이슈 #218).
+
+    예전에는 비면 채팅 안내 문구를 넣었다 — 요약·계획 JSON·노트북 같은 채팅이 아닌 호출에도
+    "기능을 적극 안내하라" 가 실렸다. 채팅 문구는 `prompts.chat_system_prompt` 이고 채팅
+    호출자(chat_service)가 넘긴다.
+    """
+    messages = []
+    if system_prompt:
+        messages.append({"role": "system", "content": system_prompt})
+    messages.append({"role": "user", "content": full_prompt})
+    return messages
+
+
+class LLMService:
+    """다양한 LLM 프로바이더와 상호작용하는 서비스"""
+
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.provider = config.get("provider", "vllm")
+
+    # ========== 설정 헬퍼 ==========
+
+    def _get_vllm_config(self) -> tuple[str, str, Dict[str, str]]:
+        """vLLM 설정 반환: (model, url, headers).
+
+        config 값이 먼저다 — `ConfigManager.get_config()` 가 이미 centri > env > 파일로
+        해석해 둔다 (이슈 #113). env 는 그 해석을 거치지 않은 config 의 폴백이다.
+        """
+        cfg = self.config.get("vllm", {})
+        endpoint = (
+            cfg.get("endpoint")
+            or os.environ.get("VLLM_ENDPOINT")
+            or "http://localhost:8000"
+        ).rstrip("/")
+        model = cfg.get("model") or os.environ.get("VLLM_MODEL") or "default"
+        # endpoint가 이미 /v1을 포함하면 중복 추가 방지
+        if endpoint.endswith("/v1"):
+            url = f"{endpoint}/chat/completions"
+        else:
+            url = f"{endpoint}/v1/chat/completions"
+        headers = {"Content-Type": "application/json"}
+        api_key = cfg.get("apiKey") or os.environ.get("VLLM_API_KEY", "")
+        if not api_key:
+            raise Exception("LLM API 키가 설정되지 않았습니다. 관리자에게 문의하세요.")
+        headers["Authorization"] = f"Bearer {api_key}"
+        return model, url, headers
+
+    # ========== 메시지/페이로드 빌더 ==========
+
+    def _build_prompt(self, prompt: str, context: Optional[str] = None) -> str:
+        """선택적 컨텍스트와 함께 전체 프롬프트 구성"""
+        if context:
+            return f"Context:\n{context}\n\nUser Request:\n{prompt}"
+        return prompt
+
+    async def _retry_with_backoff(
+        self,
+        operation,
+        max_retries: int = 3,
+        provider: str = "API",
+        retryable_statuses: tuple = (503, 429),
+    ):
+        """지수 백오프 재시도 로직으로 작업 실행"""
+        for attempt in range(max_retries):
+            try:
+                return await operation()
+            except asyncio.TimeoutError:
+                if attempt < max_retries - 1:
+                    wait_time = (2**attempt) * 3
+                    print(
+                        f"[LLMService] 요청 시간 초과. {wait_time}초 후 재시도... (시도 {attempt + 1}/{max_retries})"
+                    )
+                    await asyncio.sleep(wait_time)
+                    continue
+                raise Exception(f"{max_retries}회 재시도 후 요청 시간 초과")
+            except Exception as e:
+                error_msg = str(e)
+                # 속도 제한 (429) 오류는 재시도 가능
+                if "rate limit" in error_msg.lower() or "(429)" in error_msg:
+                    if attempt < max_retries - 1:
+                        wait_time = 40 + (attempt * 20)
+                        print(
+                            f"[LLMService] 속도 제한 도달. 재시도 전 {wait_time}초 대기... (시도 {attempt + 1}/{max_retries})"
+                        )
+                        await asyncio.sleep(wait_time)
+                        continue
+                    raise Exception(
+                        f"{max_retries}회 재시도 후 속도 제한 초과. 잠시 후 다시 시도하세요."
+                    )
+                # 서버 과부하 (503) 오류도 재시도 가능
+                if "overloaded" in error_msg.lower() or "(503)" in error_msg:
+                    if attempt < max_retries - 1:
+                        wait_time = (2**attempt) * 5
+                        print(
+                            f"[LLMService] 서버 과부하. {wait_time}초 후 재시도... (시도 {attempt + 1}/{max_retries})"
+                        )
+                        await asyncio.sleep(wait_time)
+                        continue
+                    raise
+                # 다른 API 오류는 즉시 실패
+                if "API error" in error_msg and "rate limit" not in error_msg.lower():
+                    raise
+                if "timeout" in error_msg.lower():
+                    raise
+                # 네트워크 오류 재시도
+                if attempt < max_retries - 1:
+                    wait_time = (2**attempt) * 2
+                    print(
+                        f"[LLMService] 네트워크 오류: {e}. {wait_time}초 후 재시도... (시도 {attempt + 1}/{max_retries})"
+                    )
+                    await asyncio.sleep(wait_time)
+                    continue
+                raise
+
+    @asynccontextmanager
+    async def _request(
+        self,
+        url: str,
+        payload: Dict[str, Any],
+        headers: Optional[Dict[str, str]] = None,
+        timeout_seconds: int = 60,
+        provider: str = "API",
+    ):
+        """자동 세션 정리가 포함된 HTTP POST 요청 컨텍스트 관리자"""
+        timeout = aiohttp.ClientTimeout(total=timeout_seconds)
+        connector = aiohttp.TCPConnector(ssl=False)
+        async with aiohttp.ClientSession(
+            timeout=timeout, connector=connector
+        ) as session:
+            async with session.post(url, json=payload, headers=headers) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    print(f"[LLMService] {provider} API 오류: {error_text}")
+                    if response.status in (401, 403):
+                        raise Exception(
+                            "API 키가 유효하지 않거나 만료되었습니다. "
+                            "관리자에게 문의하세요."
+                        )
+                    elif response.status == 429:
+                        raise Exception("요청 한도 초과. 잠시 후 다시 시도해주세요.")
+                    else:
+                        raise Exception(
+                            f"{provider} API 서버 오류 ({response.status}). "
+                            "엔드포인트 설정을 확인하거나 잠시 후 재시도하세요."
+                        )
+                yield response
+
+    async def _request_json(
+        self,
+        url: str,
+        payload: Dict[str, Any],
+        headers: Optional[Dict[str, str]] = None,
+        timeout_seconds: int = 60,
+        provider: str = "API",
+    ) -> Dict[str, Any]:
+        """요청 수행 및 JSON 응답 반환"""
+        async with self._request(
+            url, payload, headers, timeout_seconds, provider
+        ) as response:
+            return await response.json()
+
+    async def _stream_response(
+        self,
+        url: str,
+        payload: Dict[str, Any],
+        headers: Optional[Dict[str, str]],
+        provider: str,
+        line_parser,
+    ):
+        """응답 스트리밍 및 파싱된 콘텐츠 yield. finish_reason을 _last_finish_reason에 저장."""
+        self._last_finish_reason = None
+        async with self._request(
+            url, payload, headers, timeout_seconds=120, provider=provider
+        ) as response:
+            async for line in response.content:
+                line_text = line.decode("utf-8").strip()
+                content, finish_reason = line_parser(line_text)
+                if finish_reason:
+                    self._last_finish_reason = finish_reason
+                if content:
+                    yield content
+
+    # ========== 응답 파서 ==========
+
+    def _parse_openai_response(self, data: Dict[str, Any]) -> str:
+        """OpenAI 호환 응답 형식 파싱 (OpenAI 및 vLLM에서 사용)"""
+        if "choices" in data and len(data["choices"]) > 0:
+            choice = data["choices"][0]
+            if "message" in choice and "content" in choice["message"]:
+                return choice["message"]["content"]
+            elif "text" in choice:
+                return choice["text"]
+        raise Exception("API로부터 유효한 응답 없음")
+
+    def _parse_sse_line(
+        self, line_text: str, extractor
+    ) -> tuple[Optional[str], Optional[str]]:
+        """주어진 추출기 함수로 SSE 라인 파싱. (content, finish_reason) 반환."""
+        if not line_text.startswith("data: "):
+            return None, None
+        data_str = line_text[6:]
+        if data_str == "[DONE]":
+            return None, None
+        try:
+            data = json.loads(data_str)
+            return extractor(data)
+        except json.JSONDecodeError:
+            return None, None
+
+    def _extract_openai_chunk(
+        self, data: Dict[str, Any]
+    ) -> tuple[Optional[str], Optional[str]]:
+        """OpenAI 스트림 데이터에서 (content, finish_reason) 튜플 추출"""
+        if "choices" in data and len(data["choices"]) > 0:
+            choice = data["choices"][0]
+            delta = choice.get("delta", {})
+            content = delta.get("content", "") or None
+            finish_reason = choice.get("finish_reason")
+            return content, finish_reason
+        return None, None
+
+    def _parse_openai_stream_line(
+        self, line_text: str
+    ) -> tuple[Optional[str], Optional[str]]:
+        """OpenAI 호환 스트림의 단일 SSE 라인 파싱. (content, finish_reason) 반환."""
+        return self._parse_sse_line(line_text, self._extract_openai_chunk)
+
+    def _build_openai_payload(
+        self,
+        model: str,
+        messages: list,
+        max_tokens: int = DEFAULT_MAX_OUTPUT_TOKENS,
+        temperature: float = 0.0,
+        stream: bool = False,
+    ) -> Dict[str, Any]:
+        """OpenAI 호환 요청 페이로드 구성"""
+        return {
+            "model": model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": stream,
+        }
+
+    async def generate_response_stream(
+        self,
+        prompt: str,
+        context: Optional[str] = None,
+        max_tokens: int = DEFAULT_MAX_OUTPUT_TOKENS,
+        system_prompt: Optional[str] = None,
+    ):
+        """설정된 LLM 프로바이더로부터 스트리밍 응답 생성 (비동기 제너레이터).
+
+        finish_reason이 'length' 또는 'max_tokens'이면 자동으로 continuation 요청하여
+        응답이 잘리지 않도록 합니다 (최대 _MAX_CONTINUATIONS회).
+        """
+        if self.provider != "vllm":
+            raise ValueError(f"지원되지 않는 프로바이더: {self.provider}")
+
+        messages = _messages(self._build_prompt(prompt, context), system_prompt)
+        accumulated = ""
+
+        for attempt in range(1 + _MAX_CONTINUATIONS):
+            async for chunk in self._call_vllm_stream_internal(messages, max_tokens):
+                accumulated += chunk
+                yield chunk
+
+            if self._last_finish_reason not in ("length", "max_tokens"):
+                break  # 정상 종료
+
+            # Truncation 감지 → continuation
+            logger.info(
+                f"[LLMService] Auto-continuation triggered "
+                f"(attempt {attempt + 1}/{_MAX_CONTINUATIONS}, "
+                f"finish_reason={self._last_finish_reason})"
+            )
+            messages.append({"role": "assistant", "content": accumulated})
+            messages.append(
+                {
+                    "role": "user",
+                    "content": (
+                        "[SYSTEM] 응답이 max_tokens 한도에 도달하여 잘렸습니다. "
+                        "이전 내용에 이어서 계속 작성하세요. "
+                        "이전 내용을 반복하지 말고, 잘린 지점부터 이어서 작성하세요."
+                    ),
+                }
+            )
+            accumulated = ""  # 다음 chunk부터 새로 축적
+
+    async def generate_response(
+        self,
+        prompt: str,
+        context: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+    ) -> str:
+        """설정된 LLM 프로바이더로부터 응답 생성"""
+        if self.provider == "vllm":
+            return await self._call_vllm(prompt, context, system_prompt, max_tokens)
+        else:
+            raise ValueError(f"지원되지 않는 프로바이더: {self.provider}")
+
+    async def _call_vllm(
+        self,
+        prompt: str,
+        context: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+    ) -> str:
+        """OpenAI 호환 API로 vLLM 엔드포인트 호출"""
+        model, url, headers = self._get_vllm_config()
+        messages = _messages(self._build_prompt(prompt, context), system_prompt)
+        payload = self._build_openai_payload(
+            model,
+            messages,
+            max_tokens=max_tokens or DEFAULT_MAX_OUTPUT_TOKENS,
+            stream=False,
+        )
+
+        data = await self._request_json(url, payload, headers, provider="vLLM")
+        return self._parse_openai_response(data)
+
+    async def _call_vllm_stream_internal(
+        self, messages: list, max_tokens: int = DEFAULT_MAX_OUTPUT_TOKENS
+    ):
+        """messages를 직접 받아 스트리밍 호출 (내부용)"""
+        model, url, headers = self._get_vllm_config()
+        payload = self._build_openai_payload(
+            model, messages, max_tokens=max_tokens, stream=True
+        )
+        async for content in self._stream_response(
+            url, payload, headers, "vLLM", self._parse_openai_stream_line
+        ):
+            yield content
+
+    async def _call_vllm_stream(
+        self,
+        prompt: str,
+        context: Optional[str] = None,
+        max_tokens: int = DEFAULT_MAX_OUTPUT_TOKENS,
+        system_prompt: Optional[str] = None,
+    ):
+        """스트리밍으로 vLLM 엔드포인트 호출 (기존 인터페이스 유지)"""
+        messages = _messages(self._build_prompt(prompt, context), system_prompt)
+        async for chunk in self._call_vllm_stream_internal(messages, max_tokens):
+            yield chunk
+
+
+# Auto-Agent를 위한 모듈 수준 헬퍼 함수
+async def call_llm(
+    prompt: str, config: Dict[str, Any], context: Optional[str] = None
+) -> str:
+    """
+    주어진 설정으로 LLM을 호출하는 편의 함수.
+
+    Args:
+        prompt: LLM에 보낼 프롬프트
+        config: LLM 설정 딕셔너리
+        context: 포함할 선택적 컨텍스트
+
+    Returns:
+        LLM 응답 문자열
+    """
+    service = LLMService(config)
+    return await service.generate_response(prompt, context)
+
+
+async def call_llm_stream(
+    prompt: str, config: Dict[str, Any], context: Optional[str] = None
+):
+    """
+    주어진 설정으로 LLM 응답을 스트리밍하는 편의 함수.
+
+    Args:
+        prompt: LLM에 보낼 프롬프트
+        config: LLM 설정 딕셔너리
+        context: 포함할 선택적 컨텍스트
+
+    Yields:
+        도착하는 응답 청크
+    """
+    service = LLMService(config)
+    async for chunk in service.generate_response_stream(prompt, context):
+        yield chunk

codebuff_core/managers/__init__.py

@@ -0,0 +1,22 @@
+"""
+Codebuff Core - Managers
+
+Singleton managers for configuration, session, and RAG orchestration.
+"""
+
+from .config_manager import ConfigManager, get_config_manager
+from .session_manager import (
+    ChatMessage,
+    Session,
+    SessionManager,
+    get_session_manager,
+)
+
+__all__ = [
+    "ConfigManager",
+    "get_config_manager",
+    "ChatMessage",
+    "Session",
+    "SessionManager",
+    "get_session_manager",
+]