codebuff-agent 2.1.74__py3-none-any.whl

codebuff_core/tests/test_factory.py

@@ -0,0 +1,135 @@
+"""
+Codebuff Core - ServiceFactory Tests
+
+Tests for ServiceFactory initialization and service creation.
+"""
+
+import pytest
+
+from codebuff_core.factory import ServiceFactory, get_service_factory
+from codebuff_core.interfaces import IAgentService, IChatService, IRAGService
+
+
+class TestServiceFactorySingleton:
+    """Tests for ServiceFactory singleton pattern"""
+
+    def test_get_instance_returns_same_instance(self, reset_factory):
+        """Test get_instance returns the same instance"""
+        instance1 = ServiceFactory.get_instance()
+        instance2 = ServiceFactory.get_instance()
+        assert instance1 is instance2
+
+    def test_reset_instance_clears_singleton(self, reset_factory):
+        """Test reset_instance clears the singleton"""
+        instance1 = ServiceFactory.get_instance()
+        ServiceFactory.reset_instance()
+        instance2 = ServiceFactory.get_instance()
+        assert instance1 is not instance2
+
+    def test_get_service_factory_convenience_function(self, reset_factory):
+        """Test get_service_factory returns singleton"""
+        factory1 = get_service_factory()
+        factory2 = ServiceFactory.get_instance()
+        assert factory1 is factory2
+
+
+class TestServiceFactoryInitialization:
+    """Tests for ServiceFactory initialization"""
+
+    def test_not_initialized_by_default(self, reset_factory):
+        """Test factory is not initialized by default"""
+        factory = ServiceFactory.get_instance()
+        assert factory.is_initialized is False
+
+    @pytest.mark.asyncio
+    async def test_initialize(self, reset_factory, mock_env_embedded):
+        """Test initialization creates embedded services"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        assert factory.is_initialized is True
+
+    @pytest.mark.asyncio
+    async def test_double_initialization_is_noop(
+        self, reset_factory, mock_env_embedded
+    ):
+        """Test calling initialize twice is safe"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        await factory.initialize()  # Should not raise
+        assert factory.is_initialized is True
+
+    @pytest.mark.asyncio
+    async def test_shutdown_resets_state(self, reset_factory, mock_env_embedded):
+        """Test shutdown resets initialization state"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        assert factory.is_initialized is True
+        await factory.shutdown()
+        assert factory.is_initialized is False
+
+
+class TestServiceFactoryServiceAccess:
+    """Tests for service accessor methods"""
+
+    @pytest.mark.asyncio
+    async def test_get_agent_service_after_init(self, reset_factory, mock_env_embedded):
+        """Test get_agent_service returns service after init"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        service = factory.get_agent_service()
+        assert service is not None
+        assert isinstance(service, IAgentService)
+
+    @pytest.mark.asyncio
+    async def test_get_chat_service_after_init(self, reset_factory, mock_env_embedded):
+        """Test get_chat_service returns service after init"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        service = factory.get_chat_service()
+        assert service is not None
+        assert isinstance(service, IChatService)
+
+    @pytest.mark.asyncio
+    async def test_get_rag_service_after_init(self, reset_factory, mock_env_embedded):
+        """Test get_rag_service returns service after init"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        service = factory.get_rag_service()
+        assert service is not None
+        assert isinstance(service, IRAGService)
+
+    def test_get_agent_service_before_init_raises(self, reset_factory):
+        """Test get_agent_service raises before initialization"""
+        factory = ServiceFactory.get_instance()
+        with pytest.raises(RuntimeError, match="not initialized"):
+            factory.get_agent_service()
+
+    def test_get_chat_service_before_init_raises(self, reset_factory):
+        """Test get_chat_service raises before initialization"""
+        factory = ServiceFactory.get_instance()
+        with pytest.raises(RuntimeError, match="not initialized"):
+            factory.get_chat_service()
+
+    def test_get_rag_service_before_init_raises(self, reset_factory):
+        """Test get_rag_service raises before initialization"""
+        factory = ServiceFactory.get_instance()
+        with pytest.raises(RuntimeError, match="not initialized"):
+            factory.get_rag_service()
+
+
+class TestServiceFactoryServiceTypes:
+    """Tests for service type verification"""
+
+    @pytest.mark.asyncio
+    async def test_creates_embedded_services(self, reset_factory, mock_env_embedded):
+        """Test initialization creates EmbeddedXxxService instances"""
+        from codebuff_core.services.agent_service import EmbeddedAgentService
+        from codebuff_core.services.chat_service import EmbeddedChatService
+        from codebuff_core.services.rag_service import EmbeddedRAGService
+
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+
+        assert isinstance(factory.get_agent_service(), EmbeddedAgentService)
+        assert isinstance(factory.get_chat_service(), EmbeddedChatService)
+        assert isinstance(factory.get_rag_service(), EmbeddedRAGService)

codebuff_core/tests/test_services.py

@@ -0,0 +1,150 @@
+"""
+Codebuff Core - Service Implementation Tests
+
+Tests for Embedded service implementations.
+"""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from codebuff_core.interfaces import IAgentService, IChatService, IRAGService
+
+
+class TestEmbeddedAgentService:
+    """Tests for EmbeddedAgentService"""
+
+    @pytest.fixture
+    def embedded_agent_service(self):
+        """Create EmbeddedAgentService instance"""
+        from codebuff_core.services.agent_service import EmbeddedAgentService
+
+        return EmbeddedAgentService()
+
+    def test_implements_interface(self, embedded_agent_service):
+        """Test EmbeddedAgentService implements IAgentService"""
+        assert isinstance(embedded_agent_service, IAgentService)
+
+    @pytest.mark.asyncio
+    async def test_generate_plan_with_mock_llm(
+        self, embedded_agent_service, sample_plan_request
+    ):
+        """Test generate_plan calls LLM service"""
+        # Mock the LLM service
+        with patch.object(
+            embedded_agent_service, "_llm_service", create=True
+        ) as mock_llm:
+            mock_llm.generate_response = AsyncMock(
+                return_value='{"steps": [], "plan_id": "test"}'
+            )
+
+            # Note: Full integration test would require more mocking
+            # This is a placeholder for when LLM integration is complete
+
+
+class TestEmbeddedChatService:
+    """Tests for EmbeddedChatService"""
+
+    @pytest.fixture
+    def embedded_chat_service(self):
+        """Create EmbeddedChatService instance"""
+        from codebuff_core.services.chat_service import EmbeddedChatService
+
+        return EmbeddedChatService()
+
+    def test_implements_interface(self, embedded_chat_service):
+        """Test EmbeddedChatService implements IChatService"""
+        assert isinstance(embedded_chat_service, IChatService)
+
+
+class TestEmbeddedRAGService:
+    """Tests for EmbeddedRAGService"""
+
+    @pytest.fixture
+    def embedded_rag_service(self):
+        """Create EmbeddedRAGService instance with mocked RAG manager"""
+        from codebuff_core.services.rag_service import EmbeddedRAGService
+
+        service = EmbeddedRAGService()
+        return service
+
+    def test_implements_interface(self, embedded_rag_service):
+        """Test EmbeddedRAGService implements IRAGService"""
+        assert isinstance(embedded_rag_service, IRAGService)
+
+    def test_is_ready_before_init(self, embedded_rag_service):
+        """Test is_ready returns False before initialization"""
+        assert embedded_rag_service.is_ready() is False
+
+    @pytest.mark.asyncio
+    async def test_initialize_sets_ready(self, embedded_rag_service, mock_rag_manager):
+        """Test initialize makes service ready when RAGManager is available"""
+        # Directly set the internal state to simulate successful initialization
+        # since the actual rag_manager module might not be available
+        mock_rag_manager.is_ready = True
+        embedded_rag_service._rag_manager = mock_rag_manager
+        embedded_rag_service._initialized = True
+
+        assert embedded_rag_service.is_ready() is True
+
+    @pytest.mark.asyncio
+    async def test_initialize_is_noop(self, embedded_rag_service):
+        """Test initialize is a no-op (agent_server dependency removed)"""
+        await embedded_rag_service.initialize()
+
+        # Service is not ready because RAG is no longer supported via agent_server
+        assert embedded_rag_service.is_ready() is False
+
+
+class TestServiceInterfaceCompliance:
+    """Tests to verify all services implement their interfaces correctly"""
+
+    def test_all_agent_service_methods_exist(self):
+        """Verify all IAgentService methods are implemented"""
+        from codebuff_core.services.agent_service import EmbeddedAgentService
+
+        required_methods = [
+            "generate_plan",
+            "refine_code",
+            "replan",
+            "validate_code",
+        ]
+
+        for method in required_methods:
+            assert hasattr(EmbeddedAgentService, method), (
+                f"EmbeddedAgentService missing {method}"
+            )
+            assert callable(getattr(EmbeddedAgentService, method))
+
+    def test_all_chat_service_methods_exist(self):
+        """Verify all IChatService methods are implemented"""
+        from codebuff_core.services.chat_service import EmbeddedChatService
+
+        required_methods = [
+            "send_message",
+            "send_message_stream",
+        ]
+
+        for method in required_methods:
+            assert hasattr(EmbeddedChatService, method), (
+                f"EmbeddedChatService missing {method}"
+            )
+            assert callable(getattr(EmbeddedChatService, method))
+
+    def test_all_rag_service_methods_exist(self):
+        """Verify all IRAGService methods are implemented"""
+        from codebuff_core.services.rag_service import EmbeddedRAGService
+
+        required_methods = [
+            "search",
+            "get_context_for_query",
+            "is_ready",
+            "get_index_status",
+            "trigger_reindex",
+        ]
+
+        for method in required_methods:
+            assert hasattr(EmbeddedRAGService, method), (
+                f"EmbeddedRAGService missing {method}"
+            )
+            assert callable(getattr(EmbeddedRAGService, method))

jupyter_ext/__init__.py

@@ -0,0 +1,266 @@
+"""
+Codebuff Agent.
+
+In-process execution via ServiceFactory and WebSocket agent.
+Configuration: ~/.jupyter/codebuff_config.json
+"""
+
+import asyncio
+import os
+import sys
+import traceback
+
+from ._version import __version__
+
+
+def _setup_local_imports():
+    """Add local codebuff_core to sys.path for direct source imports."""
+    from pathlib import Path
+
+    # jupyter_ext/__init__.py → extensions/jupyter/jupyter_ext/
+    # codebuff_core source: repo_root/codebuff_core/
+    repo_root = Path(__file__).resolve().parent.parent.parent.parent
+    core_path = str(repo_root / "codebuff_core")
+    if core_path not in sys.path:
+        sys.path.insert(0, core_path)
+
+
+_setup_local_imports()
+
+
+# SSL certificate setup for macOS
+if sys.platform == "darwin":
+    try:
+        import certifi
+
+        os.environ["SSL_CERT_FILE"] = certifi.where()
+        os.environ["REQUESTS_CA_BUNDLE"] = certifi.where()
+    except ImportError:
+        pass
+
+
+def _jupyter_labextension_paths():
+    """Called by JupyterLab to find extension."""
+    return [{"src": "labextension", "dest": "codebuff"}]
+
+
+def _jupyter_server_extension_points():
+    """Called by Jupyter Server to enable extension."""
+    return [{"module": "jupyter_ext"}]
+
+
+def _ensure_config_files():
+    """Automatically create necessary configuration files on first run."""
+    import json
+    import shutil
+    from pathlib import Path
+
+    try:
+        jupyter_config_dir = Path.home() / ".jupyter"
+        jupyter_server_config_d = jupyter_config_dir / "jupyter_server_config.d"
+
+        # 1. Create jupyter_server_config.d directory
+        jupyter_server_config_d.mkdir(parents=True, exist_ok=True)
+
+        # 2. Copy codebuff.json (server extension registration)
+        dest_server_config = jupyter_server_config_d / "codebuff_agent.json"
+        if not dest_server_config.exists():
+            source_server_config = (
+                Path(__file__).parent
+                / "etc"
+                / "jupyter"
+                / "jupyter_server_config.d"
+                / "codebuff_agent.json"
+            )
+            if source_server_config.exists():
+                shutil.copy(source_server_config, dest_server_config)
+
+        # 3. Create codebuff_config.json (Agent settings - default values)
+        config_file = jupyter_config_dir / "codebuff_config.json"
+        legacy_config_file = jupyter_config_dir / "hdsp_agent_config.json"
+        if not config_file.exists() and not legacy_config_file.exists():
+            default_config = {
+                "provider": "vllm",
+                "vllm": {
+                    "endpoint": "https://openrouter.ai/api/v1",
+                    "apiKey": "",
+                    "model": "openai/gpt-oss-120b",
+                },
+            }
+            with open(config_file, "w") as f:
+                json.dump(default_config, f, indent=2)
+
+    except Exception:
+        # Configuration file creation failure is not fatal, ignore silently
+        pass
+
+
+async def _initialize_service_factory(server_app):
+    """Initialize ServiceFactory if codebuff_core is available."""
+    try:
+        from codebuff_core.factory import get_service_factory
+
+        factory = get_service_factory()
+        await factory.initialize()
+
+        server_app.log.info("Codebuff ServiceFactory initialized")
+
+        rag_service = factory.get_rag_service()
+        rag_ready = rag_service.is_ready()
+        server_app.log.info(f"  RAG service ready: {rag_ready}")
+
+    except ImportError:
+        # codebuff_core not available, skip ServiceFactory initialization
+        pass
+    except Exception as e:
+        server_app.log.warning(f"ServiceFactory initialization failed: {e}")
+
+
+def _schedule_initialization(server_app):
+    """Schedule async initialization in the event loop."""
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            asyncio.ensure_future(_initialize_service_factory(server_app))
+        else:
+            loop.run_until_complete(_initialize_service_factory(server_app))
+    except RuntimeError:
+        asyncio.run(_initialize_service_factory(server_app))
+
+
+def load_jupyter_server_extension(server_app):
+    """Load the Jupyter Server extension."""
+    # [Auto-config] Create config files if they don't exist
+    _ensure_config_files()
+
+    # [Secrets] AWS Secrets Manager → 연결정보 env 주입 (HDSP_ENV=dev/prod일 때).
+    # 서비스/ConfigManager가 읽기 전에 실행. 실패해도 기동은 계속(채팅 시 노출).
+    try:
+        from .secrets_bootstrap import bootstrap_secrets
+
+        bootstrap_secrets()
+    except Exception as _e:  # noqa: BLE001
+        server_app.log.warning(f"[Secrets] bootstrap skipped: {_e}")
+
+    # [Central config] centri 에서 조직 설정을 주기적으로 받는다 (이슈 #113).
+    # env 주입 뒤여야 URL 을 본다. URL 이 없으면 스레드를 띄우지 않는다.
+    try:
+        from codebuff_core.managers.remote_config import start_from_env
+
+        from .team_access import resolve_team, user_ids
+
+        # 팀은 env 가 비면 JWT 팀 클레임으로 — centri 가 팀 단위 값을 고르는 축이다.
+        # 사번은 로그 대조용이다 — 사용자 층은 centri 가 토큰으로 고른다 (이슈 #181)
+        start_from_env(team=resolve_team(), user_ids=user_ids())
+    except Exception as _e:  # noqa: BLE001
+        server_app.log.warning(f"[Central config] start skipped: {_e}")
+
+    # [Custom skills] centri 포털에서 편집한 스킬을 받아 동기화 디렉터리에 쓴다 (이슈 #134).
+    # 기동은 첫 받기를 기다리지 않는다. URL 이 없으면 스레드를 띄우지 않는다.
+    # 같은 스레드가 로컬 스킬 목록을 centri 에 보고한다 (이슈 #182).
+    try:
+        import functools
+
+        from codebuff_core.managers import remote_skills
+
+        from .agent.tool_report import agent_tools_report
+        from .http_handlers import local_skills_report
+        from .team_access import resolve_team, user_ids
+
+        remote_skills.start_from_env(
+            team=resolve_team(),
+            project=os.environ.get("HDSP_PRJ_ID", ""),
+            user_ids=user_ids(),
+            local_source=functools.partial(
+                local_skills_report,
+                server_app.web_app.settings.get("server_root_dir", os.getcwd()),
+            ),
+            # 에이전트 도구 정의도 같은 보고에 싣는다 (이슈 #248)
+            tools_source=agent_tools_report,
+        )
+    except Exception as _e:  # noqa: BLE001
+        server_app.log.warning(f"[Custom skills] start skipped: {_e}")
+
+    # [Background] 지난 서버가 kill -9 로 죽으며 남긴 백그라운드 프로세스를 거둔다 (이슈 #130)
+    try:
+        from .agent.background_procs import reap_orphans
+
+        reaped = reap_orphans()
+        if reaped:
+            server_app.log.info(f"[Background] 남은 프로세스 {reaped}개를 거뒀습니다")
+    except Exception as _e:  # noqa: BLE001
+        server_app.log.warning(f"[Background] reap skipped: {_e}")
+
+    try:
+        from .http_handlers import setup_handlers
+
+        web_app = server_app.web_app
+        setup_handlers(web_app)
+
+        # Expose environment variables to client via PageConfig
+        # This allows frontend to access HDSP_ENV, HDSP_PRJ_ID, JUPYTERHUB_USER
+        page_config = web_app.settings.setdefault("page_config_data", {})
+
+        # Add HDSP environment variables
+        hdsp_env = os.environ.get("HDSP_ENV", "")
+        hdsp_prj_id = os.environ.get("HDSP_PRJ_ID", "")
+        jupyterhub_user = os.environ.get("JUPYTERHUB_USER", "")
+        hdsp_bdp_id = os.environ.get("HDSP_BDP_ID", "")
+
+        if hdsp_env:
+            page_config["HDSP_ENV"] = hdsp_env
+        if hdsp_prj_id:
+            page_config["HDSP_PRJ_ID"] = hdsp_prj_id
+        if jupyterhub_user:
+            page_config["JUPYTERHUB_USER"] = jupyterhub_user
+        if hdsp_bdp_id:
+            page_config["HDSP_BDP_ID"] = hdsp_bdp_id
+
+        server_app.log.info(
+            f"Exposed HDSP env vars to client: HDSP_ENV={hdsp_env}, HDSP_PRJ_ID={hdsp_prj_id}, JUPYTERHUB_USER={jupyterhub_user}, HDSP_BDP_ID={hdsp_bdp_id}"
+        )
+
+        # Keycloak JWT: Extract team claim for access control
+        from .team_access import read_user_team
+
+        team_claim_name = os.environ.get("HDSP_TEAM_CLAIM_NAME", "hcc_team")
+        user_team = read_user_team()
+        if user_team:
+            server_app.log.info(
+                f"Decoded Keycloak JWT: team claim '{team_claim_name}' = '{user_team}'"
+            )
+
+        page_config["HDSP_USER_TEAM"] = user_team
+        page_config["HDSP_TEAM_CLAIM_NAME"] = team_claim_name
+        page_config["CODEBUFF_EXTENSION_VERSION"] = __version__
+
+        # Build time
+        from pathlib import Path
+
+        _build_time_path = Path(__file__).parent / "_build_time.txt"
+        _build_time = ""
+        if _build_time_path.exists():
+            _build_time = _build_time_path.read_text().strip()
+        page_config["CODEBUFF_BUILD_TIME"] = _build_time
+
+        server_app.log.info(f"User team from Keycloak: {user_team or '(not set)'}")
+
+        server_app.log.info("Codebuff Agent loaded (v%s)", __version__)
+        _schedule_initialization(server_app)
+
+        # Start server-side idle monitor
+        try:
+            from .idle_monitor import ServerIdleMonitor
+
+            idle_monitor = ServerIdleMonitor(server_app)
+            idle_monitor.start()
+            web_app.settings["codebuff_idle_monitor"] = idle_monitor
+        except Exception as idle_err:
+            server_app.log.warning(
+                f"Server-side idle monitor failed to start: {idle_err}"
+            )
+
+    except Exception as e:
+        server_app.log.error(f"Failed to load Codebuff Agent: {e}")
+        server_app.log.error(traceback.format_exc())
+        raise e

jupyter_ext/_version.py

@@ -0,0 +1,4 @@
+# This file is auto-generated by Hatchling. As such, do not:
+#   - modify
+#   - track in version control e.g. be sure to add to .gitignore
+__version__ = VERSION = '2.1.74'

jupyter_ext/agent/__init__.py

@@ -0,0 +1,49 @@
+"""Agent module for Codebuff.
+
+All imports are lazy to avoid pulling in deepagents/langgraph at module load time.
+This prevents ImportError when deepagents is missing or has breaking changes.
+"""
+
+import importlib as _importlib
+
+# Backward compatibility alias
+DeepAgentRunner = None  # populated on first access
+
+__all__ = [
+    "AgentConfig",
+    "AgentEvent",
+    "AgentFactory",
+    "AgentRunner",
+    "DSMemoryMiddleware",
+    "DeepAgentRunner",
+    "MemoryEntry",
+    "MemoryStore",
+    "config_from_dict",
+]
+
+_FACTORY_NAMES = {
+    "AgentConfig",
+    "AgentEvent",
+    "AgentFactory",
+    "AgentRunner",
+    "config_from_dict",
+}
+
+_MIDDLEWARE_NAMES = {
+    "DSMemoryMiddleware",
+    "MemoryEntry",
+    "MemoryStore",
+}
+
+
+def __getattr__(name: str):
+    if name in _FACTORY_NAMES:
+        mod = _importlib.import_module(".agent_factory", __name__)
+        return getattr(mod, name)
+    if name in _MIDDLEWARE_NAMES:
+        mod = _importlib.import_module(".middleware", __name__)
+        return getattr(mod, name)
+    if name == "DeepAgentRunner":
+        mod = _importlib.import_module(".agent_factory", __name__)
+        return mod.AgentRunner
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")