hdsp-jupyter-extension 2.0.0__py3-none-any.whl

agent_server/knowledge/watchdog_service.py

@@ -0,0 +1,352 @@
+"""
+Watchdog Service - File system monitoring for automatic RAG re-indexing.
+
+Features:
+- Monitors knowledge base directory for changes
+- Debounces rapid file changes
+- Triggers incremental re-indexing
+- Pattern-based file filtering
+"""
+
+import asyncio
+import logging
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable, Optional, Set
+
+if TYPE_CHECKING:
+    from hdsp_agent_core.models.rag import WatchdogConfig
+
+logger = logging.getLogger(__name__)
+
+
+class WatchdogService:
+    """
+    File system monitoring service for RAG knowledge base.
+
+    Features:
+    - Asynchronous file change detection
+    - Debouncing to prevent excessive re-indexing
+    - Pattern-based filtering (*.md, *.py, etc.)
+    - Ignore patterns for cache/build directories
+    - Callback-based notification
+
+    Usage:
+        service = WatchdogService(config, on_change_callback)
+        service.start("/path/to/knowledge")
+        # ... later
+        service.stop()
+    """
+
+    def __init__(
+        self,
+        config: "WatchdogConfig",
+        on_change_callback: Optional[Callable[[Set[Path]], None]] = None,
+    ):
+        self._config = config
+        self._on_change = on_change_callback
+        self._observer = None
+        self._running = False
+        self._pending_changes: Set[Path] = set()
+        self._last_change_time: Optional[datetime] = None
+        self._debounce_task: Optional[asyncio.Task] = None
+        self._lock = threading.Lock()
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+
+    def start(self, watch_path: Path) -> bool:
+        """
+        Start monitoring the specified directory.
+
+        Args:
+            watch_path: Directory to monitor
+
+        Returns:
+            True if monitoring started successfully
+        """
+        if not self._config.enabled:
+            logger.info("Watchdog disabled by configuration")
+            return False
+
+        if self._running:
+            logger.warning("Watchdog already running")
+            return True
+
+        try:
+            from watchdog.events import FileSystemEvent, FileSystemEventHandler
+            from watchdog.observers import Observer
+        except ImportError:
+            logger.warning(
+                "watchdog not installed, file monitoring disabled. "
+                "Install with: pip install watchdog"
+            )
+            return False
+
+        if not watch_path.exists():
+            logger.warning(f"Watch path does not exist: {watch_path}")
+            return False
+
+        # Store event loop for async callbacks
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = None
+
+        # Create event handler
+        handler = self._create_event_handler(FileSystemEventHandler)
+
+        # Start observer
+        self._observer = Observer()
+        self._observer.schedule(handler, str(watch_path), recursive=True)
+        self._observer.start()
+        self._running = True
+
+        logger.info(f"Watchdog started monitoring: {watch_path}")
+        return True
+
+    def _create_event_handler(self, base_class):
+        """Create a watchdog event handler class."""
+        service = self
+
+        class RAGEventHandler(base_class):
+            def on_any_event(self, event):
+                if event.is_directory:
+                    return
+
+                # Get file path
+                file_path = Path(event.src_path)
+
+                # Check if file matches patterns
+                if not service._should_process(file_path):
+                    return
+
+                # Queue the change
+                service._queue_change(file_path)
+
+        return RAGEventHandler()
+
+    def _should_process(self, file_path: Path) -> bool:
+        """Check if file should trigger re-indexing."""
+        file_name = file_path.name
+
+        # Check ignore patterns
+        for pattern in self._config.ignore_patterns:
+            if file_name.startswith(pattern.replace("*", "")):
+                return False
+            if pattern.startswith("*") and file_name.endswith(pattern[1:]):
+                return False
+
+        # Check include patterns
+        for pattern in self._config.patterns:
+            if pattern.startswith("*"):
+                suffix = pattern[1:]
+                if file_name.endswith(suffix):
+                    return True
+            elif file_name == pattern:
+                return True
+
+        return False
+
+    def _queue_change(self, file_path: Path) -> None:
+        """Queue a file change for processing."""
+        with self._lock:
+            self._pending_changes.add(file_path)
+            self._last_change_time = datetime.now()
+
+        logger.debug(f"Queued change: {file_path}")
+
+        # Schedule debounced processing
+        if self._loop and self._loop.is_running():
+            self._loop.call_soon_threadsafe(self._schedule_debounce)
+
+    def _schedule_debounce(self) -> None:
+        """Schedule the debounced callback."""
+        if self._debounce_task and not self._debounce_task.done():
+            self._debounce_task.cancel()
+
+        self._debounce_task = asyncio.create_task(self._debounced_callback())
+
+    async def _debounced_callback(self) -> None:
+        """Wait for debounce period then trigger callback."""
+        try:
+            await asyncio.sleep(self._config.debounce_seconds)
+
+            # Get pending changes
+            with self._lock:
+                if not self._pending_changes:
+                    return
+
+                changes = self._pending_changes.copy()
+                self._pending_changes.clear()
+
+            logger.info(f"Processing {len(changes)} file changes")
+
+            # Trigger callback
+            if self._on_change:
+                try:
+                    self._on_change(changes)
+                except Exception as e:
+                    logger.error(f"Error in change callback: {e}")
+
+        except asyncio.CancelledError:
+            # Debounce was reset, ignore
+            pass
+        except Exception as e:
+            logger.error(f"Error in debounced callback: {e}")
+
+    def stop(self) -> None:
+        """Stop file monitoring."""
+        if not self._running:
+            return
+
+        if self._observer:
+            self._observer.stop()
+            self._observer.join(timeout=5)
+            self._observer = None
+
+        if self._debounce_task and not self._debounce_task.done():
+            self._debounce_task.cancel()
+
+        self._running = False
+        self._pending_changes.clear()
+
+        logger.info("Watchdog stopped")
+
+    @property
+    def is_running(self) -> bool:
+        """Check if watchdog is currently running."""
+        return self._running
+
+    @property
+    def pending_count(self) -> int:
+        """Get number of pending changes."""
+        with self._lock:
+            return len(self._pending_changes)
+
+
+class SimpleWatchdog:
+    """
+    Simplified watchdog for polling-based monitoring.
+
+    Use this when the watchdog library is not available
+    or for environments where filesystem events are unreliable.
+    """
+
+    def __init__(
+        self,
+        patterns: list[str] = None,
+        check_interval: float = 10.0,
+        on_change_callback: Optional[Callable[[Set[Path]], None]] = None,
+    ):
+        self._patterns = patterns or ["*.md", "*.py", "*.txt"]
+        self._check_interval = check_interval
+        self._on_change = on_change_callback
+        self._running = False
+        self._file_mtimes: dict[Path, float] = {}
+        self._check_task: Optional[asyncio.Task] = None
+
+    async def start(self, watch_path: Path) -> bool:
+        """Start polling-based monitoring."""
+        if self._running:
+            return True
+
+        if not watch_path.exists():
+            logger.warning(f"Watch path does not exist: {watch_path}")
+            return False
+
+        self._running = True
+        self._check_task = asyncio.create_task(self._poll_loop(watch_path))
+
+        logger.info(f"SimpleWatchdog started polling: {watch_path}")
+        return True
+
+    async def _poll_loop(self, watch_path: Path) -> None:
+        """Main polling loop."""
+        # Initial scan
+        self._scan_directory(watch_path)
+
+        while self._running:
+            try:
+                await asyncio.sleep(self._check_interval)
+
+                if not self._running:
+                    break
+
+                # Check for changes
+                changes = self._check_changes(watch_path)
+
+                if changes and self._on_change:
+                    try:
+                        self._on_change(changes)
+                    except Exception as e:
+                        logger.error(f"Error in change callback: {e}")
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error in poll loop: {e}")
+
+    def _scan_directory(self, watch_path: Path) -> None:
+        """Scan directory and record file mtimes."""
+        for pattern in self._patterns:
+            for file_path in watch_path.rglob(pattern.lstrip("*")):
+                if file_path.is_file():
+                    try:
+                        self._file_mtimes[file_path] = file_path.stat().st_mtime
+                    except OSError:
+                        pass
+
+    def _check_changes(self, watch_path: Path) -> Set[Path]:
+        """Check for file changes since last scan."""
+        changes = set()
+        current_files: Set[Path] = set()
+
+        # Check existing files
+        for pattern in self._patterns:
+            suffix = pattern.lstrip("*")
+            for file_path in watch_path.rglob(f"*{suffix}"):
+                if not file_path.is_file():
+                    continue
+
+                current_files.add(file_path)
+
+                try:
+                    mtime = file_path.stat().st_mtime
+                except OSError:
+                    continue
+
+                # Check if new or modified
+                if file_path not in self._file_mtimes:
+                    changes.add(file_path)
+                    self._file_mtimes[file_path] = mtime
+                elif self._file_mtimes[file_path] != mtime:
+                    changes.add(file_path)
+                    self._file_mtimes[file_path] = mtime
+
+        # Check for deleted files
+        deleted = set(self._file_mtimes.keys()) - current_files
+        for file_path in deleted:
+            del self._file_mtimes[file_path]
+            # Note: We don't add deleted files to changes
+            # The RAG system should handle missing files gracefully
+
+        return changes
+
+    async def stop(self) -> None:
+        """Stop polling."""
+        self._running = False
+
+        if self._check_task and not self._check_task.done():
+            self._check_task.cancel()
+            try:
+                await self._check_task
+            except asyncio.CancelledError:
+                pass
+
+        self._file_mtimes.clear()
+        logger.info("SimpleWatchdog stopped")
+
+    @property
+    def is_running(self) -> bool:
+        """Check if watchdog is currently running."""
+        return self._running

agent_server/main.py

@@ -0,0 +1,160 @@
+"""
+HDSP Agent Server - FastAPI Entry Point
+
+AI Agent Server for IDE integrations (JupyterLab, VS Code, PyCharm)
+
+This server always runs in embedded mode (HDSP_AGENT_MODE=embedded)
+since it's the actual implementation server that executes agent logic.
+"""
+
+import logging
+import os
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from agent_server.routers import agent, chat, config, file_resolver, health, rag
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan handler for startup/shutdown events"""
+    # Startup
+    logger.info("Starting HDSP Agent Server...")
+
+    # Force embedded mode for the server (it IS the implementation)
+    os.environ.setdefault("HDSP_AGENT_MODE", "embedded")
+
+    try:
+        from hdsp_agent_core.factory import get_service_factory
+
+        factory = get_service_factory()
+        await factory.initialize()
+
+        logger.info(f"ServiceFactory initialized in {factory.mode.value} mode")
+
+        # Log service status
+        rag_service = factory.get_rag_service()
+        if rag_service.is_ready():
+            logger.info("RAG service ready")
+        else:
+            logger.info("RAG service not ready (will start without RAG)")
+
+    except ImportError as e:
+        logger.warning(f"hdsp_agent_core not available: {e}")
+        # Fallback to legacy initialization
+        await _legacy_startup()
+    except Exception as e:
+        logger.warning(f"Failed to initialize ServiceFactory: {e}")
+        # Fallback to legacy initialization
+        await _legacy_startup()
+
+    yield
+
+    # Shutdown
+    logger.info("Shutting down HDSP Agent Server...")
+
+    try:
+        from hdsp_agent_core.factory import get_service_factory
+
+        factory = get_service_factory()
+        await factory.shutdown()
+        logger.info("ServiceFactory shutdown complete")
+    except Exception as e:
+        logger.warning(f"Error during ServiceFactory shutdown: {e}")
+        # Fallback to legacy shutdown
+        await _legacy_shutdown()
+
+
+async def _legacy_startup():
+    """Legacy startup for backward compatibility (when hdsp_agent_core not available)"""
+    logger.info("Using legacy startup (hdsp_agent_core not available)")
+
+    try:
+        from hdsp_agent_core.managers.config_manager import ConfigManager
+
+        ConfigManager.get_instance()
+        logger.info("Configuration loaded successfully")
+    except Exception as e:
+        logger.warning(f"Failed to load configuration: {e}")
+
+    # Initialize RAG system
+    try:
+        from hdsp_agent_core.models.rag import get_default_rag_config
+
+        from agent_server.core.rag_manager import get_rag_manager
+
+        rag_config = get_default_rag_config()
+        if rag_config.is_enabled():
+            rag_manager = get_rag_manager(rag_config)
+            await rag_manager.initialize()
+            logger.info("RAG system initialized successfully")
+        else:
+            logger.info("RAG system disabled by configuration")
+    except Exception as e:
+        logger.warning(f"Failed to initialize RAG system: {e}")
+
+
+async def _legacy_shutdown():
+    """Legacy shutdown for backward compatibility"""
+    logger.info("Using legacy shutdown")
+
+    try:
+        from agent_server.core.rag_manager import get_rag_manager, reset_rag_manager
+
+        rag_manager = get_rag_manager()
+        if rag_manager.is_ready:
+            await rag_manager.shutdown()
+            logger.info("RAG system shut down successfully")
+        reset_rag_manager()
+    except Exception as e:
+        logger.warning(f"Error during legacy RAG shutdown: {e}")
+
+
+app = FastAPI(
+    title="HDSP Agent Server",
+    description="AI Agent Server for IDE integrations - provides intelligent code assistance",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+# CORS middleware for cross-origin requests from IDE extensions
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Development: allow all. Production: restrict
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Register routers
+app.include_router(health.router, tags=["Health"])
+app.include_router(config.router, prefix="/config", tags=["Configuration"])
+app.include_router(agent.router, prefix="/agent", tags=["Agent"])
+app.include_router(chat.router, prefix="/chat", tags=["Chat"])
+app.include_router(rag.router, prefix="/rag", tags=["RAG"])
+app.include_router(file_resolver.router, prefix="/file", tags=["File Resolution"])
+
+
+def run():
+    """Entry point for `hdsp-agent-server` CLI command"""
+    import uvicorn
+
+    uvicorn.run(
+        "agent_server.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+    )
+
+
+if __name__ == "__main__":
+    run()

agent_server/prompts/__init__.py

@@ -0,0 +1,60 @@
+"""
+HDSP Agent Prompts Module
+
+Re-export from hdsp_agent_core.prompts for backward compatibility.
+"""
+
+# Auto-Agent Prompts
+from hdsp_agent_core.prompts.auto_agent_prompts import (
+    ADAPTIVE_REPLAN_PROMPT,
+    CODE_GENERATION_PROMPT,
+    ERROR_REFINEMENT_PROMPT,
+    FINAL_ANSWER_PROMPT,
+    PLAN_GENERATION_PROMPT,
+    REFLECTION_PROMPT,
+    STRUCTURED_PLAN_PROMPT,
+    format_final_answer_prompt,
+    format_plan_prompt,
+    format_refine_prompt,
+    format_reflection_prompt,
+    format_replan_prompt,
+    format_structured_plan_prompt,
+)
+
+# Cell Action Prompts
+from hdsp_agent_core.prompts.cell_action_prompts import (
+    CUSTOM_REQUEST_PROMPT,
+    DEFAULT_SYSTEM_PROMPT,
+    EXPLAIN_CODE_PROMPT,
+    FIX_CODE_PROMPT,
+    format_chat_prompt,
+    format_custom_prompt,
+    format_explain_prompt,
+    format_fix_prompt,
+)
+
+__all__ = [
+    # Auto-Agent Prompts
+    "PLAN_GENERATION_PROMPT",
+    "CODE_GENERATION_PROMPT",
+    "ERROR_REFINEMENT_PROMPT",
+    "ADAPTIVE_REPLAN_PROMPT",
+    "FINAL_ANSWER_PROMPT",
+    "STRUCTURED_PLAN_PROMPT",
+    "REFLECTION_PROMPT",
+    "format_plan_prompt",
+    "format_refine_prompt",
+    "format_final_answer_prompt",
+    "format_replan_prompt",
+    "format_structured_plan_prompt",
+    "format_reflection_prompt",
+    # Cell Action Prompts
+    "EXPLAIN_CODE_PROMPT",
+    "FIX_CODE_PROMPT",
+    "CUSTOM_REQUEST_PROMPT",
+    "DEFAULT_SYSTEM_PROMPT",
+    "format_explain_prompt",
+    "format_fix_prompt",
+    "format_custom_prompt",
+    "format_chat_prompt",
+]

agent_server/prompts/file_action_prompts.py

@@ -0,0 +1,113 @@
+"""
+File Action Prompts
+Python 파일 분석 및 에러 수정용 LLM 프롬프트
+"""
+
+
+def format_file_fix_prompt(
+    main_file: dict, error_output: str, related_files: list = None
+) -> str:
+    """Python 파일 에러 수정용 프롬프트 생성
+
+    Args:
+        main_file: { 'path': str, 'content': str }
+        error_output: 에러 메시지/트레이스백
+        related_files: [{ 'path': str, 'content': str }]
+    """
+    related_context = ""
+    if related_files:
+        related_context = "\n## 관련 파일들\n"
+        for rf in related_files:
+            if rf.get("content"):
+                related_context += f"""
+### {rf['path']}
+```python
+{rf['content']}
+```
+"""
+
+    return f"""Python 파일에서 에러가 발생했습니다. 에러를 분석하고 수정된 코드를 제공하세요.
+
+## 에러 메시지
+```
+{error_output}
+```
+
+## 메인 파일: {main_file['path']}
+```python
+{main_file['content']}
+```
+{related_context}
+
+## 지침
+1. 에러의 근본 원인을 분석하세요
+2. 수정이 필요한 파일의 **전체 코드**를 제공하세요 (부분 수정 아님)
+3. 여러 파일 수정이 필요하면 각각 제공하세요
+4. 수정 사항을 간단히 설명하세요
+5. **코드 내 주석과 문자열은 한글 또는 영어로만 작성하세요 (한자 사용 절대 금지)**
+
+## 출력 형식
+### 에러 원인
+(에러가 발생한 원인 설명)
+
+### 수정 파일: [파일경로]
+```python
+[전체 수정된 코드]
+```
+
+### 추가 수정 파일: [파일경로] (필요한 경우)
+```python
+[전체 수정된 코드]
+```
+"""
+
+
+def format_file_explain_prompt(file_path: str, file_content: str) -> str:
+    """Python 파일 설명용 프롬프트 생성"""
+    return f"""다음 Python 파일의 코드를 자세히 설명해주세요.
+
+## 파일: {file_path}
+```python
+{file_content}
+```
+
+## 다음 형식으로 응답해주세요
+
+### 파일 개요
+(이 파일의 전체적인 목적과 기능)
+
+### 주요 구성 요소
+(클래스, 함수, 변수 등의 설명)
+
+### 코드 흐름
+(코드의 실행 흐름 설명)
+
+### 의존성
+(import하는 모듈과 그 용도)
+"""
+
+
+def format_file_custom_prompt(
+    main_file: dict, custom_prompt: str, related_files: list = None
+) -> str:
+    """커스텀 질문용 프롬프트 생성"""
+    related_context = ""
+    if related_files:
+        related_context = "\n## 관련 파일들\n"
+        for rf in related_files:
+            if rf.get("content"):
+                related_context += f"""
+### {rf['path']}
+```python
+{rf['content']}
+```
+"""
+
+    return f"""{custom_prompt}
+
+## 메인 파일: {main_file['path']}
+```python
+{main_file['content']}
+```
+{related_context}
+"""

agent_server/routers/__init__.py

@@ -0,0 +1,9 @@
+"""
+Agent Server Routers
+
+FastAPI routers for the HDSP Agent Server.
+"""
+
+from . import agent, chat, config, health, rag
+
+__all__ = ["agent", "chat", "config", "health", "rag"]