hdsp-jupyter-extension 2.0.7__py3-none-any.whl → 2.0.8__py3-none-any.whl

agent_server/langchain/tools/lsp_tools.py

@@ -0,0 +1,264 @@
+"""
+LSP Tools for LangChain Agent
+
+Provides tools for LSP (Language Server Protocol) integration:
+- diagnostics_tool: Get code diagnostics (errors, warnings)
+- references_tool: Find symbol references
+
+Crush 패턴 적용:
+- 진단 결과 포맷팅 (severity 기반 정렬)
+- 출력 제한 (최대 10개 + 요약)
+- Grep-then-LSP 패턴 (references)
+"""
+
+from typing import Any, Dict, List, Optional
+
+from langchain_core.tools import tool
+from pydantic import BaseModel, Field
+
+
+class DiagnosticsInput(BaseModel):
+    """Input schema for diagnostics tool"""
+
+    path: Optional[str] = Field(
+        default=None,
+        description="File path to get diagnostics for. If not provided, returns project-wide diagnostics.",
+    )
+    severity_filter: Optional[str] = Field(
+        default=None,
+        description="Filter by severity: 'error', 'warning', 'hint', or None for all",
+    )
+    execution_result: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="LSP diagnostics result from client",
+    )
+
+
+class ReferencesInput(BaseModel):
+    """Input schema for references tool"""
+
+    symbol: str = Field(description="Symbol name to find references for")
+    path: Optional[str] = Field(
+        default=None,
+        description="File path where the symbol is located (optional)",
+    )
+    line: Optional[int] = Field(
+        default=None, description="Line number (1-indexed, optional)"
+    )
+    character: Optional[int] = Field(
+        default=None, description="Character position (optional)"
+    )
+    execution_result: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="LSP references result from client",
+    )
+
+
+@tool(args_schema=DiagnosticsInput)
+def diagnostics_tool(
+    path: Optional[str] = None,
+    severity_filter: Optional[str] = None,
+    execution_result: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Get LSP diagnostics (errors, warnings) for a file or the entire project.
+
+    Use this tool to:
+    - Check for syntax errors before running code
+    - Find type errors in Python/TypeScript files
+    - Identify unused imports or variables
+    - Verify code quality issues after editing
+
+    The diagnostics are provided by language servers (pylsp, etc.)
+    and are more accurate than simple linting.
+
+    **Best Practice**: Always check diagnostics after editing code:
+    1. edit_file_tool(...) - make changes
+    2. diagnostics_tool(path="file.py") - verify no new errors
+
+    Args:
+        path: Optional file path. None = project-wide diagnostics
+        severity_filter: Optional filter ('error', 'warning', 'hint')
+
+    Returns:
+        Formatted diagnostics with severity, location, and message
+    """
+    if execution_result is None:
+        # Client needs to execute this
+        return {
+            "tool": "diagnostics_tool",
+            "parameters": {
+                "path": path,
+                "severity_filter": severity_filter,
+            },
+            "status": "pending_execution",
+            "message": "Diagnostics request queued for LSP bridge execution",
+        }
+
+    # Process client result (Crush 패턴)
+    diagnostics = execution_result.get("diagnostics", [])
+    lsp_available = execution_result.get("lsp_available", False)
+
+    if not lsp_available:
+        return {
+            "tool": "diagnostics_tool",
+            "success": True,
+            "output": "LSP not available. Install jupyterlab-lsp for code diagnostics.\nUse search_workspace_tool for text-based code search instead.",
+            "counts": {"errors": 0, "warnings": 0, "total": 0},
+        }
+
+    # Severity ordering (errors first)
+    severity_order = {"error": 0, "warning": 1, "information": 2, "hint": 3}
+
+    # Sort diagnostics
+    sorted_diags = sorted(
+        diagnostics,
+        key=lambda d: (
+            severity_order.get(d.get("severity", "hint"), 3),
+            d.get("file", ""),
+            d.get("line", 0),
+        ),
+    )
+
+    # Filter by severity if specified
+    if severity_filter:
+        sorted_diags = [
+            d for d in sorted_diags if d.get("severity") == severity_filter
+        ]
+
+    # Format output (Crush의 formatDiagnostics 패턴)
+    formatted_lines = []
+    for d in sorted_diags[:10]:  # 최대 10개
+        severity = d.get("severity", "hint").upper()
+        line = d.get("line", 0)
+        col = d.get("character", 0)
+        source = d.get("source", "")
+        code = d.get("code", "")
+        message = d.get("message", "")
+        file = d.get("file", path or "")
+
+        location = f"{file}:{line}:{col}" if file else f"L{line}:{col}"
+        source_info = f"[{source}]" if source else ""
+        code_info = f"[{code}]" if code else ""
+
+        formatted_lines.append(
+            f"{severity} {location} {source_info}{code_info} {message}"
+        )
+
+    # Calculate counts
+    total = len(diagnostics)
+    errors = sum(1 for d in diagnostics if d.get("severity") == "error")
+    warnings = sum(1 for d in diagnostics if d.get("severity") == "warning")
+
+    # Add summary
+    summary = f"\n--- Summary: {errors} errors, {warnings} warnings, {total} total"
+    if total > 10:
+        summary += f" (showing first 10)"
+
+    output = (
+        "\n".join(formatted_lines) + summary
+        if formatted_lines
+        else f"No diagnostics found.{' LSP is available.' if lsp_available else ''}"
+    )
+
+    return {
+        "tool": "diagnostics_tool",
+        "success": True,
+        "output": output,
+        "counts": {"errors": errors, "warnings": warnings, "total": total},
+    }
+
+
+@tool(args_schema=ReferencesInput)
+def references_tool(
+    symbol: str,
+    path: Optional[str] = None,
+    line: Optional[int] = None,
+    character: Optional[int] = None,
+    execution_result: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Find all references to a symbol across the codebase.
+
+    Use this tool to:
+    - Check if a function/class is used before renaming/deleting
+    - Understand how a variable is used throughout the code
+    - Find all usages before refactoring
+
+    If LSP is not available, falls back to search_workspace_tool.
+
+    Args:
+        symbol: Symbol name (function, class, variable)
+        path: Optional file path where symbol is located
+        line: Optional line number (1-indexed)
+        character: Optional character position
+
+    Returns:
+        List of locations where the symbol is referenced
+    """
+    if execution_result is None:
+        return {
+            "tool": "references_tool",
+            "parameters": {
+                "symbol": symbol,
+                "path": path,
+                "line": line,
+                "character": character,
+            },
+            "status": "pending_execution",
+            "message": "References search queued for execution",
+        }
+
+    locations = execution_result.get("locations", [])
+    lsp_available = execution_result.get("lsp_available", False)
+    used_grep = execution_result.get("used_grep", False)
+
+    if not locations:
+        if not lsp_available:
+            return {
+                "tool": "references_tool",
+                "success": True,
+                "output": f"LSP not available. Use search_workspace_tool with pattern='{symbol}' for text-based search.",
+                "count": 0,
+            }
+        return {
+            "tool": "references_tool",
+            "success": True,
+            "output": f"No references found for '{symbol}'",
+            "count": 0,
+        }
+
+    # Group by file (Crush 패턴)
+    by_file: Dict[str, List] = {}
+    for loc in locations:
+        file = loc.get("file", "unknown")
+        if file not in by_file:
+            by_file[file] = []
+        by_file[file].append(loc)
+
+    # Format output
+    method_note = " (grep-based)" if used_grep else " (LSP)"
+    formatted_lines = [f"Found {len(locations)} references to '{symbol}'{method_note}:\n"]
+
+    for file, locs in sorted(by_file.items()):
+        formatted_lines.append(f"\n📄 {file}")
+        for loc in sorted(locs, key=lambda x: x.get("line", 0)):
+            line_num = loc.get("line", 0)
+            col = loc.get("character", 0)
+            preview = (loc.get("preview", "") or "")[:60]
+            formatted_lines.append(f"  L{line_num}:{col}  {preview}")
+
+    return {
+        "tool": "references_tool",
+        "success": True,
+        "output": "\n".join(formatted_lines),
+        "count": len(locations),
+        "by_file": {f: len(locs) for f, locs in by_file.items()},
+    }
+
+
+# Export all LSP tools
+LSP_TOOLS = [
+    diagnostics_tool,
+    references_tool,
+]

agent_server/main.py

@@ -32,6 +32,13 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Reduce verbose logging from LangChain/LangGraph
+# These libraries log entire message histories which creates excessive duplicate logs
+logging.getLogger("langchain").setLevel(logging.WARNING)
+logging.getLogger("langchain_core").setLevel(logging.WARNING)
+logging.getLogger("langgraph").setLevel(logging.WARNING)
+logging.getLogger("langsmith").setLevel(logging.WARNING)
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):

agent_server/routers/langchain_agent.py

@@ -561,23 +561,50 @@ async def stream_agent(request: AgentRequest):
             # Prepare config with thread_id
             config = {"configurable": {"thread_id": thread_id}}
 
-            # Debug: Check if there's existing state for this thread
+            # Check existing state and reset todos if all completed
+            should_reset_todos = False
             try:
                 existing_state = checkpointer.get(config)
                 if existing_state:
-                    existing_messages = existing_state.get("channel_values", {}).get(
-                        "messages", []
-                    )
+                    channel_values = existing_state.get("channel_values", {})
+                    existing_messages = channel_values.get("messages", [])
+                    existing_todos = channel_values.get("todos", [])
                     logger.info(
-                        "Existing state for thread %s: %d messages found",
+                        "Existing state for thread %s: %d messages, %d todos found",
                         thread_id,
                         len(existing_messages),
+                        len(existing_todos),
                     )
+                    # Check if all todos are completed - if so, reset them
+                    if existing_todos:
+                        all_completed = all(
+                            t.get("status") == "completed" for t in existing_todos
+                        )
+                        if all_completed:
+                            should_reset_todos = True
+                            logger.info(
+                                "All %d todos are completed, will reset for new task",
+                                len(existing_todos),
+                            )
                 else:
                     logger.info("No existing state for thread %s", thread_id)
             except Exception as e:
                 logger.warning("Could not check existing state: %s", e)
 
+            # Reset todos in agent state if all were completed
+            todos_reset_event = None
+            if should_reset_todos:
+                try:
+                    agent.update_state(config, {"todos": []})
+                    logger.info("Reset todos in agent state for thread %s", thread_id)
+                    # Prepare event to notify frontend (will be yielded after function setup)
+                    todos_reset_event = {
+                        "event": "todos",
+                        "data": json.dumps({"todos": [], "reset": True}),
+                    }
+                except Exception as e:
+                    logger.warning("Could not reset todos in agent state: %s", e)
+
             # Prepare input
             agent_input = {"messages": [{"role": "user", "content": request.request}]}
 
@@ -593,6 +620,11 @@ async def stream_agent(request: AgentRequest):
             emitted_contents: set = set()
             _simple_agent_emitted_contents[thread_id] = emitted_contents
 
+            # Emit todos reset event if needed (before starting the stream)
+            if todos_reset_event:
+                logger.info("SSE: Emitting todos reset event")
+                yield todos_reset_event
+
             # Initial status: waiting for LLM
             logger.info("SSE: Sending initial debug status '🤔 LLM 응답 대기 중'")
             yield {
@@ -695,11 +727,27 @@ async def stream_agent(request: AgentRequest):
                                     final_answer = tool_result.get(
                                         "answer"
                                     ) or tool_result.get("parameters", {}).get("answer")
+                                    
+                                    # Check for next_items in answer field (LLM may put JSON here)
+                                    if final_answer:
+                                        try:
+                                            answer_json = json.loads(final_answer)
+                                            if "next_items" in answer_json:
+                                                next_items_block = f"\n\n```json\n{json.dumps(answer_json, ensure_ascii=False, indent=2)}\n```"
+                                                # Get summary for the main text
+                                                summary_text = tool_result.get(
+                                                    "summary"
+                                                ) or tool_result.get("parameters", {}).get("summary") or ""
+                                                final_answer = summary_text + next_items_block
+                                                logger.info("Extracted next_items from answer field")
+                                        except (json.JSONDecodeError, TypeError):
+                                            pass
+                                    
                                     # Check for next_items in summary field (Gemini puts JSON here)
                                     summary = tool_result.get(
                                         "summary"
                                     ) or tool_result.get("parameters", {}).get("summary")
-                                    if summary:
+                                    if summary and "next_items" not in (final_answer or ""):
                                         try:
                                             summary_json = json.loads(summary)
                                             if "next_items" in summary_json:
@@ -1388,9 +1436,26 @@ async def resume_agent(request: ResumeRequest):
             )
             # Get or create cached agent
             resolved_workspace_root = _resolve_workspace_root(request.workspaceRoot)
-            checkpointer = _simple_agent_checkpointers.setdefault(
-                request.threadId, InMemorySaver()
-            )
+
+            # CRITICAL: Validate checkpoint exists before resume
+            # InMemorySaver is volatile - server restart loses all checkpoints
+            if request.threadId not in _simple_agent_checkpointers:
+                logger.warning(
+                    "Resume failed: No checkpoint found for thread %s. "
+                    "Server may have restarted or session expired.",
+                    request.threadId,
+                )
+                yield {
+                    "event": "error",
+                    "data": json.dumps({
+                        "error": "Session expired or not found",
+                        "code": "CHECKPOINT_NOT_FOUND",
+                        "message": "이전 세션을 찾을 수 없습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
+                    }),
+                }
+                return
+
+            checkpointer = _simple_agent_checkpointers.get(request.threadId)
 
             agent_cache_key = _get_agent_cache_key(
                 llm_config=config_dict,
@@ -1612,11 +1677,27 @@ async def resume_agent(request: ResumeRequest):
                                     final_answer = tool_result.get(
                                         "answer"
                                     ) or tool_result.get("parameters", {}).get("answer")
+                                    
+                                    # Check for next_items in answer field (LLM may put JSON here)
+                                    if final_answer:
+                                        try:
+                                            answer_json = json.loads(final_answer)
+                                            if "next_items" in answer_json:
+                                                next_items_block = f"\n\n```json\n{json.dumps(answer_json, ensure_ascii=False, indent=2)}\n```"
+                                                # Get summary for the main text
+                                                summary_text = tool_result.get(
+                                                    "summary"
+                                                ) or tool_result.get("parameters", {}).get("summary") or ""
+                                                final_answer = summary_text + next_items_block
+                                                logger.info("Resume: Extracted next_items from answer field")
+                                        except (json.JSONDecodeError, TypeError):
+                                            pass
+                                    
                                     # Check for next_items in summary field (Gemini puts JSON here)
                                     summary = tool_result.get(
                                         "summary"
                                     ) or tool_result.get("parameters", {}).get("summary")
-                                    if summary:
+                                    if summary and "next_items" not in (final_answer or ""):
                                         try:
                                             summary_json = json.loads(summary)
                                             if "next_items" in summary_json:
@@ -1966,16 +2047,31 @@ async def resume_agent(request: ResumeRequest):
             }
 
         except Exception as e:
-            logger.error(f"Resume error: {e}", exc_info=True)
-            yield {
-                "event": "error",
-                "data": json.dumps(
-                    {
-                        "error": str(e),
+            error_msg = str(e)
+            logger.error(f"Resume error: {error_msg}", exc_info=True)
+
+            # Detect specific Gemini error for empty contents
+            if "contents is not specified" in error_msg.lower():
+                logger.warning(
+                    "Detected 'contents is not specified' error - likely session state loss"
+                )
+                yield {
+                    "event": "error",
+                    "data": json.dumps({
+                        "error": "Session state lost",
+                        "code": "CONTENTS_NOT_SPECIFIED",
                         "error_type": type(e).__name__,
-                    }
-                ),
-            }
+                        "message": "세션 상태가 손실되었습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
+                    }),
+                }
+            else:
+                yield {
+                    "event": "error",
+                    "data": json.dumps({
+                        "error": error_msg,
+                        "error_type": type(e).__name__,
+                    }),
+                }
 
     return EventSourceResponse(event_generator())
 

agent_server/routers/rag.py

@@ -105,9 +105,14 @@ async def reindex(request: ReindexRequest) -> ReindexResponse:
         )
 
     try:
-        # For now, return a simple success response
-        # Full reindex implementation would go here
-        return ReindexResponse(success=True, indexed=0, skipped=0, errors=[])
+        # Trigger actual reindexing
+        result = await rag_manager._index_knowledge_base()
+        return ReindexResponse(
+            success=True,
+            indexed=result["indexed"],
+            skipped=result["skipped"],
+            errors=result["errors"],
+        )
 
     except Exception as e:
         logger.error(f"Reindex failed: {e}")

hdsp_agent_core/models/rag.py

@@ -41,12 +41,26 @@ class QdrantConfig(BaseModel):
         description="Vector collection name"
     )
 
+    def get_mode(self) -> str:
+        """Get mode with environment variable override"""
+        env_mode = os.environ.get("QDRANT_MODE")
+        if env_mode:
+            return env_mode
+        return self.mode
+
+    def get_url(self) -> str:
+        """Get URL with environment variable override"""
+        env_url = os.environ.get("QDRANT_URL")
+        if env_url:
+            return env_url
+        return self.url or "http://localhost:6333"
+
     def get_local_path(self) -> str:
         """Get resolved local path with environment variable support"""
         if self.local_path:
             return os.path.expanduser(self.local_path)
         # Check environment variable
-        env_path = os.environ.get("HDSP_QDRANT_PATH")
+        env_path = os.environ.get("QDRANT_PATH")
         if env_path:
             return os.path.expanduser(env_path)
         # Default path

hdsp_agent_core/services/rag_service.py

@@ -35,8 +35,13 @@ class EmbeddedRAGService(IRAGService):
             return
 
         try:
-            from hdsp_agent_core.managers.rag_manager import get_rag_manager
+            from agent_server.core.rag_manager import get_rag_manager
+
             self._rag_manager = get_rag_manager()
+
+            # Initialize RAG system
+            await self._rag_manager.initialize()
+
             self._initialized = True
             logger.info("EmbeddedRAGService initialized with RAGManager")
         except ImportError as e:

{hdsp_jupyter_extension-2.0.7.data → hdsp_jupyter_extension-2.0.8.data}/data/share/jupyter/labextensions/hdsp-agent/build_log.json

@@ -722,7 +722,7 @@
             "@mui/material": {},
             "react-markdown": {},
             "hdsp-agent": {
-              "version": "2.0.7",
+              "version": "2.0.8",
               "singleton": true,
               "import": "/Users/a421721/Desktop/hdsp/hdsp_agent/extensions/jupyter/lib/index.js"
             }

{hdsp_jupyter_extension-2.0.7.data → hdsp_jupyter_extension-2.0.8.data}/data/share/jupyter/labextensions/hdsp-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdsp-agent",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "HDSP Agent JupyterLab Extension - Thin client for Agent Server",
   "keywords": [
     "jupyter",
@@ -70,6 +70,7 @@
     "@jupyterlab/launcher": "^4.0.0",
     "@jupyterlab/notebook": "^4.0.0",
     "@jupyterlab/services": "^7.0.0",
+    "@jupyterlab/terminal": "^4.0.0",
     "@lumino/widgets": "^2.0.0",
     "@mui/icons-material": "^7.3.4",
     "@mui/material": "^5.14.0",
@@ -126,7 +127,7 @@
       }
     },
     "_build": {
-      "load": "static/remoteEntry.61343eb4cf0577e74b50.js",
+      "load": "static/remoteEntry.020cdb0b864cfaa4e41e.js",
       "extension": "./extension",
       "style": "./style"
     }