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

agent_server/langchain/hitl_config.py

@@ -32,17 +32,9 @@ def get_hitl_interrupt_config() -> Dict[str, Any]:
             "allowed_decisions": ["approve", "edit"],
             "description": "📄 파일 읽기 실행 중",
         },
-        "list_files_tool": {
-            "allowed_decisions": ["approve", "edit"],
-            "description": "📂 파일 목록 조회 중",
-        },
         "write_todos": False,  # Todo updates don't need approval
         # Search tools need HITL for client-side execution (auto-approved by frontend)
         # Uses 'edit' decision to pass execution_result back
-        "search_workspace_tool": {
-            "allowed_decisions": ["approve", "edit"],
-            "description": "🔍 Searching workspace files",
-        },
         "search_notebook_cells_tool": {
             "allowed_decisions": ["approve", "edit"],
             "description": "🔍 Searching notebook cells",
@@ -66,6 +58,11 @@ def get_hitl_interrupt_config() -> Dict[str, Any]:
             "allowed_decisions": ["approve", "edit", "reject"],
             "description": "File edit requires approval",
         },
+        # Multi-edit requires approval (multiple string replacements atomically)
+        "multiedit_file_tool": {
+            "allowed_decisions": ["approve", "edit", "reject"],
+            "description": "Multi-edit requires approval",
+        },
         # Final answer doesn't need approval
         "final_answer_tool": False,
     }

agent_server/langchain/logging_utils.py

@@ -116,7 +116,7 @@ def _with_middleware_logging(name: str):
 
 class LLMTraceLogger(BaseCallbackHandler):
     """Log prompts, responses, tool calls, and tool messages.
-    
+
     Only logs newly added messages to avoid duplicate logging of conversation history.
     Uses content hash of first message (usually system prompt) to identify conversation threads.
     """
@@ -126,7 +126,7 @@ class LLMTraceLogger(BaseCallbackHandler):
         # Track last logged message count per conversation thread
         # Key: hash of first message content, Value: message count
         self._last_message_counts: Dict[str, int] = {}
-    
+
     def _get_conversation_key(self, batch) -> str:
         """Get a stable key for the conversation based on first message content."""
         if not batch:
@@ -136,7 +136,7 @@ class LLMTraceLogger(BaseCallbackHandler):
         # Use hash of first 200 chars of first message (usually system prompt)
         content_preview = str(content)[:200] if content else ""
         return str(hash(content_preview))
-    
+
     def _normalize_batches(self, messages):
         if not messages:
             return []
@@ -151,7 +151,7 @@ class LLMTraceLogger(BaseCallbackHandler):
             conv_key = self._get_conversation_key(batch)
             batch_key = f"{conv_key}_{batch_idx}"
             last_count = self._last_message_counts.get(batch_key, 0)
-            
+
             # Only log new messages
             new_messages = batch[last_count:]
             if not new_messages:
@@ -161,13 +161,13 @@ class LLMTraceLogger(BaseCallbackHandler):
                     last_count,
                 )
                 continue
-            
+
             # Update count
             self._last_message_counts[batch_key] = len(batch)
-            
+
             # Log with offset info
             header = f"{title} (batch={batch_idx}, new={len(new_messages)}, total={len(batch)})"
-            
+
             # Format new messages with correct indices
             lines = [LOG_SEPARATOR, header, LOG_SEPARATOR]
             for idx, message in enumerate(new_messages, start=last_count):

agent_server/langchain/prompts.py

@@ -5,129 +5,119 @@ Contains system prompts, JSON schema for fallback tool calling,
 and middleware-specific prompts.
 """
 
-DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter notebook assistant.
-Your role is to help users with data analysis, visualization, and Python coding tasks in Jupyter notebooks. You can use only Korean
-
-# Core Behavior
-Be concise and direct. Answer in fewer than 4 lines unless the user asks for detail.
-After working on a file, just stop - don't explain what you did unless asked.
-Avoid unnecessary introductions or conclusions.
-
-## Task Management
-Use write_todos for complex multi-step tasks (3+ steps). Mark tasks in_progress before starting, completed immediately after finishing.
-For simple 1-2 step tasks, just do them directly without todos.
-
-You MUST ALWAYS call a tool in every response. After any tool result, you MUST:
-1. Check your todo list - are there pending or in_progress items?
-2. If YES → call the next appropriate tool (jupyter_cell_tool, markdown_tool, etc.)
-3. When you suggest next steps for todo item '다음 단계 제시', you MUST create next steps in json format matching this schema:
-{
-  "next_items": [
-    {
-        "subject": "<subject for next step>",
-        "description": "<detailed description for the next step>"
-    }, ...
-  ]
-}
-4. If ALL todos are completed → call final_answer_tool with a summary
-
-## 🔴 MANDATORY: Resource Check Before Data Hanlding
-**ALWAYS call check_resource_tool FIRST** when the task involves:
-- Loading files: .csv, .parquet, .json, .xlsx, .pickle, .h5, .feather
-- Handling datasets(dataframe) with pandas, polars, dask, or similar libraries
-- Training ML models on data files
-
-## Mandatory Workflow
-1. After EVERY tool result, immediately call the next tool
-2. Continue until ALL todos show status: "completed"
-3. ONLY THEN call final_answer_tool to summarize
-4. Only use jupyter_cell_tool for Python code or when the user explicitly asks to run in a notebook cell
-5. For plots and charts, use English text only.
-
-## ❌ FORBIDDEN (will break the workflow)
-- Producing an empty response (no tool call, no content)
-- Stopping after any tool without calling the next tool
-- Ending without calling final_answer_tool
-- Leaving todos in "in_progress" or "pending" state without continuing
-
-## 📖 File Reading Best Practices
-**CRITICAL**: When exploring codebases or reading files, use pagination to prevent context overflow.
-
-**Pattern for codebase exploration:**
-1. First scan: `read_file_tool(path, limit=100)` - See file structure and key sections
-2. Targeted read: `read_file_tool(path, offset=100, limit=200)` - Read specific sections if needed
-3. Full read: Only read without limit when necessary for immediate editing
-
-**When to paginate (use offset/limit):**
-- Reading any file >500 lines
-- Exploring unfamiliar codebases (always start with limit=100)
-- Reading multiple files in sequence
-- Any research or investigation task
-
-**When full read is OK:**
-- Small files (<500 lines)
-- Files you need to edit immediately after reading
-- After confirming file size with first scan
-
-## 🔧 Code Development
-For code generation/refactoring, use LSP tools (diagnostics_tool, references_tool) to check errors and find symbol usages. Use multiedit_file_tool for multiple changes in one file.
+DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter notebook assistant. Respond in Korean only.
+
+# Core Rules
+1. Be concise (≤4 lines unless detail requested)
+2. ALWAYS call a tool in every response - never respond with text only
+3. ALWAYS include a brief Korean explanation before tool calls
+
+# Task Workflow
+
+## Simple Tasks (1-2 steps)
+Execute directly without todos.
+
+## Complex Tasks (3+ steps)
+1. Create todos with write_todos (all items in Korean)
+2. ALWAYS include "작업 요약 및 다음단계 제시" as the LAST item
+3. After each tool result: check todos → call next tool → repeat
+4. **Final todo ("작업 요약 및 다음단계 제시")**:
+   - FIRST: Output summary JSON in your content (REQUIRED!)
+   - THEN: Call write_todos to mark all as completed
+   - Both must be in the SAME response
+
+### Summary JSON Format (MUST output before marking complete)
+```json
+{"summary": "실행된 작업 요약", "next_items": [{"subject": "제목", "description": "설명"}]}
+```
+Suggest 3-5 next items. **You CANNOT mark "작업 요약" as completed without outputting this JSON first.**
+
+# Mandatory Checks
+
+## Resource Check (BEFORE data operations)
+Call `check_resource_tool` FIRST when:
+- Loading files (.csv, .parquet, .json, .xlsx, .pickle, .h5, .feather)
+- Using pandas/polars/dask for dataframes
+- Training ML models
+
+# Tool Usage
+
+## File Search (execute_command_tool)
+```bash
+find . -iname '*filename*.csv' 2>/dev/null     # Find by name
+grep -rn 'pattern' --include='*.py' .           # Search contents
+```
+
+## File Reading (read_file_tool)
+- Large files: `read_file_tool(path, limit=100)` first
+- Use `offset` for pagination
+- Small files (<500 lines): Read without limit
+
+## Code Output
+- For plots/charts: Use English labels only
+- Use LSP tools for error checking and symbol lookup
+- Use multiedit_file_tool for multiple changes
+
+# Forbidden
+- Empty responses (no tool call AND no content)
+- Tool calls without Korean explanation
+- Stopping with pending/in_progress todos
 """
 
-JSON_TOOL_SCHEMA = """You MUST respond with ONLY valid JSON matching this schema:
-{
-  "tool": "<tool_name>",
-  "arguments": {"arg1": "value1", ...}
-}
+JSON_TOOL_SCHEMA = """Respond with ONLY valid JSON:
+{"tool": "<name>", "arguments": {...}}
+
+Tools:
+- jupyter_cell_tool: {"code": "<python>"}
+- markdown_tool: {"content": "<markdown>"}
+- write_todos: {"todos": [{"content": "한국어 내용", "status": "pending|in_progress|completed"}]}
+- read_file_tool: {"path": "<path>", "offset": 0, "limit": 500}
+- write_file_tool: {"path": "<path>", "content": "<content>", "overwrite": false}
+- search_notebook_cells_tool: {"pattern": "<regex>"}
+- execute_command_tool: {"command": "<cmd>"}
+- check_resource_tool: {"files": ["<path>"], "dataframes": ["<var>"]}
 
-Available tools:
-- jupyter_cell_tool: Execute Python code. Arguments: {"code": "<python_code>"}
-- markdown_tool: Add markdown cell. Arguments: {"content": "<markdown>"}
-- final_answer_tool: Complete task. Arguments: {"answer": "<summary>"}
-- write_todos: Update task list. Arguments: {"todos": [{"content": "...", "status": "pending|in_progress|completed"}]}
-- read_file_tool: Read file with pagination. Arguments: {"path": "<file_path>", "offset": 0, "limit": 500}
-- write_file_tool: Write file. Arguments: {"path": "<path>", "content": "<content>", "overwrite": false}
-- list_files_tool: List directory. Arguments: {"path": ".", "recursive": false}
-- search_workspace_tool: Search files. Arguments: {"pattern": "<regex>", "file_types": ["py"], "path": "."}
-- search_notebook_cells_tool: Search notebook cells. Arguments: {"pattern": "<regex>"}
-- execute_command_tool: Execute shell command. Arguments: {"command": "<command>", "stdin": "<input_for_prompts>"}
-- check_resource_tool: Check resources before data processing. Arguments: {"files": ["<path>"], "dataframes": ["<var_name>"]}
-
-Output ONLY the JSON object, no markdown, no explanation."""
+No markdown wrapping. JSON only."""
 
 TODO_LIST_SYSTEM_PROMPT = """
-## CRITICAL WORKFLOW RULES - MUST FOLLOW:
-- NEVER stop after calling write_todos - ALWAYS make another tool call immediately
-- For simple 1-2 step tasks, just do them directly without todos.
-
-## 🔴 NEW USER MESSAGE = FRESH START:
-- When user sends a NEW message, treat it as a COMPLETELY NEW TASK
-- IGNORE any previous todo completion history - start fresh
-- Do NOT assume any work was already done based on past conversations
-- Create a NEW todo list for the new request, even if similar items existed before
-- "다음 단계 제시" from a previous task is NOT completed for the new task
-
-## Todo List Management:
-- Before complex tasks, use write_todos to create a task list
-- Update todos as you complete each step (mark 'in_progress' → 'completed')
-- Each todo item should be specific and descriptive
-- All todo items must be written in Korean
-- ALWAYS include "다음 단계 제시" as the LAST item
-
-## Task Completion Flow:
-1. When current task is done → mark it 'completed' with write_todos
-2. For "다음 단계 제시" → mark completed, then call final_answer_tool with suggestions
-
-## FORBIDDEN PATTERNS:
-❌ Calling write_todos and then stopping
-❌ Updating todo status without doing the actual work
-❌ Ending turn without calling final_answer_tool when all tasks are done
-❌ Marking a todo as 'completed' without actually executing it in THIS conversation
+# Todo Rules
+
+## New Message = Fresh Start
+- Each user message is a NEW task
+- Ignore completion status from chat history
+- Execute ALL current todos from scratch
+
+## Structure
+All todo items must be in Korean. Always end with:
+- 작업 요약 및 다음단계 제시  ← 필수 마지막 항목!
+
+## Workflow
+1. Find pending/in_progress todo
+2. Execute it NOW in THIS response
+3. Mark completed
+4. Repeat until all done
+
+## 🔴 Final Todo ("작업 요약 및 다음단계 제시") - CRITICAL
+When executing this todo, you MUST:
+1. Output the summary JSON in your content FIRST:
+   {"summary": "작업 내용 요약", "next_items": [{"subject": "...", "description": "..."}]}
+2. THEN call write_todos to mark all as completed
+3. If you don't output the JSON, the todo will NOT be marked as completed!
+
+## Completion Check
+- ✅ Done: Executed in THIS response
+- ❌ Not done: Only visible in chat history
+- ❌ "작업 요약" cannot be completed without outputting summary JSON
+
+## Forbidden
+- Marking complete without executing in THIS response
+- Marking "작업 요약" complete without outputting JSON summary
+- Todos without "작업 요약 및 다음단계 제시" as final item
 """
 
-TODO_LIST_TOOL_DESCRIPTION = """Update the task list for tracking progress.
-⚠️ CRITICAL: This tool is ONLY for tracking - it does NOT do any actual work.
-After calling this tool, you MUST IMMEDIATELY call another tool (jupyter_cell_tool, markdown_tool, or final_answer_tool).
-NEVER end your response after calling write_todos - always continue with the next action tool."""
+TODO_LIST_TOOL_DESCRIPTION = """Update task list for tracking progress.
+This tool ONLY tracks status - does NOT execute tasks.
+After calling: immediately call next action tool (unless ALL completed)."""
 
 # Non-HITL tools that execute immediately without user approval
 NON_HITL_TOOLS = {
@@ -135,10 +125,6 @@ NON_HITL_TOOLS = {
     "markdown",
     "read_file_tool",
     "read_file",
-    "list_files_tool",
-    "list_files",
-    "search_workspace_tool",
-    "search_workspace",
     "search_notebook_cells_tool",
     "search_notebook_cells",
     "write_todos",

agent_server/langchain/tools/__init__.py

@@ -4,14 +4,11 @@ LangChain Tools for Jupyter Agent
 Tools available:
 - jupyter_cell: Execute Python code in notebook
 - markdown: Add markdown cell
-- final_answer: Complete the task
 - read_file: Read file content
 - write_file: Write file content
 - edit_file: Edit file with string replacement
-- list_files: List directory contents
-- search_workspace: Search files in workspace
 - search_notebook_cells: Search cells in notebooks
-- execute_command_tool: Run shell commands (client-executed)
+- execute_command_tool: Run shell commands (client-executed, also for file search)
 - check_resource_tool: Check resources before data processing (client-executed)
 - diagnostics_tool: Get LSP diagnostics (errors, warnings)
 - references_tool: Find symbol references via LSP
@@ -19,13 +16,11 @@ Tools available:
 
 from agent_server.langchain.tools.file_tools import (
     edit_file_tool,
-    list_files_tool,
     multiedit_file_tool,
     read_file_tool,
     write_file_tool,
 )
 from agent_server.langchain.tools.jupyter_tools import (
-    final_answer_tool,
     jupyter_cell_tool,
     markdown_tool,
 )
@@ -36,20 +31,16 @@ from agent_server.langchain.tools.lsp_tools import (
 from agent_server.langchain.tools.resource_tools import check_resource_tool
 from agent_server.langchain.tools.search_tools import (
     search_notebook_cells_tool,
-    search_workspace_tool,
 )
 from agent_server.langchain.tools.shell_tools import execute_command_tool
 
 __all__ = [
     "jupyter_cell_tool",
     "markdown_tool",
-    "final_answer_tool",
     "read_file_tool",
     "write_file_tool",
     "edit_file_tool",
     "multiedit_file_tool",
-    "list_files_tool",
-    "search_workspace_tool",
     "search_notebook_cells_tool",
     "execute_command_tool",
     "check_resource_tool",

agent_server/langchain/tools/file_tools.py

@@ -5,7 +5,6 @@ Provides tools for file system operations:
 - read_file: Read file content
 - write_file: Write content to file (requires approval)
 - edit_file: Edit file with string replacement (requires approval)
-- list_files: List directory contents
 """
 
 import os
@@ -70,21 +69,6 @@ class EditFileInput(BaseModel):
     )
 
 
-class ListFilesInput(BaseModel):
-    """Input schema for list_files tool"""
-
-    path: str = Field(default=".", description="Directory path to list")
-    recursive: bool = Field(default=False, description="Whether to list recursively")
-    pattern: Optional[str] = Field(
-        default=None,
-        description="Glob pattern to filter files (e.g., '*.py', '*.ipynb')",
-    )
-    execution_result: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="Optional execution result payload from the client",
-    )
-
-
 def _validate_path(path: str, workspace_root: str = ".") -> str:
     """
     Validate and resolve file path.
@@ -315,50 +299,13 @@ def edit_file_tool(
         }
 
 
-@tool(args_schema=ListFilesInput)
-def list_files_tool(
-    path: str = ".",
-    recursive: bool = False,
-    pattern: Optional[str] = None,
-    execution_result: Optional[Dict[str, Any]] = None,
-    workspace_root: str = ".",
-) -> Dict[str, Any]:
-    """
-    List files and directories.
-
-    Args:
-        path: Directory path to list (default: current directory)
-        recursive: Whether to list recursively
-        pattern: Optional glob pattern to filter (e.g., '*.py')
-
-    Returns:
-        Dict with list of files and directories
-    """
-    response: Dict[str, Any] = {
-        "tool": "list_files_tool",
-        "parameters": {
-            "path": path,
-            "recursive": recursive,
-            "pattern": pattern,
-        },
-        "status": "pending_execution",
-        "message": "File listing queued for execution by client",
-    }
-    if execution_result is not None:
-        response["execution_result"] = execution_result
-        response["status"] = "complete"
-        response["message"] = "File listing executed with client-reported results"
-    return response
-
-
 class EditOperation(BaseModel):
     """Single edit operation for multiedit_file tool"""
 
     old_string: str = Field(description="The exact string to find and replace")
     new_string: str = Field(description="The replacement string")
     replace_all: bool = Field(
-        default=False,
-        description="Whether to replace all occurrences (default: false)"
+        default=False, description="Whether to replace all occurrences (default: false)"
     )
 
 
@@ -456,12 +403,14 @@ def multiedit_file_tool(
 
             old_preview = (old_str[:50] + "...") if len(old_str) > 50 else old_str
             new_preview = (new_str[:50] + "...") if len(new_str) > 50 else new_str
-            edits_preview.append({
-                "index": i,
-                "old_preview": old_preview,
-                "new_preview": new_preview,
-                "replace_all": replace_all_val
-            })
+            edits_preview.append(
+                {
+                    "index": i,
+                    "old_preview": old_preview,
+                    "new_preview": new_preview,
+                    "replace_all": replace_all_val,
+                }
+            )
 
         # Convert all edits to dicts for serialization
         for edit in edits:
@@ -515,5 +464,4 @@ FILE_TOOLS = [
     write_file_tool,
     edit_file_tool,
     multiedit_file_tool,
-    list_files_tool,
 ]

agent_server/langchain/tools/jupyter_tools.py

@@ -139,5 +139,4 @@ def final_answer_tool(answer: str, summary: Optional[str] = None) -> Dict[str, A
 JUPYTER_TOOLS = [
     jupyter_cell_tool,
     markdown_tool,
-    final_answer_tool,
 ]

agent_server/langchain/tools/lsp_tools.py

@@ -103,7 +103,7 @@ def diagnostics_tool(
         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.",
+            "output": "LSP not available. Install jupyterlab-lsp for code diagnostics.\nUse execute_command_tool with grep for text-based code search instead.",
             "counts": {"errors": 0, "warnings": 0, "total": 0},
         }
 
@@ -122,9 +122,7 @@ def diagnostics_tool(
 
     # Filter by severity if specified
     if severity_filter:
-        sorted_diags = [
-            d for d in sorted_diags if d.get("severity") == severity_filter
-        ]
+        sorted_diags = [d for d in sorted_diags if d.get("severity") == severity_filter]
 
     # Format output (Crush의 formatDiagnostics 패턴)
     formatted_lines = []
@@ -153,7 +151,7 @@ def diagnostics_tool(
     # Add summary
     summary = f"\n--- Summary: {errors} errors, {warnings} warnings, {total} total"
     if total > 10:
-        summary += f" (showing first 10)"
+        summary += " (showing first 10)"
 
     output = (
         "\n".join(formatted_lines) + summary
@@ -185,7 +183,7 @@ def references_tool(
     - 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.
+    If LSP is not available, falls back to execute_command_tool with grep.
 
     Args:
         symbol: Symbol name (function, class, variable)
@@ -218,7 +216,7 @@ def references_tool(
             return {
                 "tool": "references_tool",
                 "success": True,
-                "output": f"LSP not available. Use search_workspace_tool with pattern='{symbol}' for text-based search.",
+                "output": f"LSP not available. Use execute_command_tool with grep with pattern='{symbol}' for text-based search.",
                 "count": 0,
             }
         return {
@@ -238,7 +236,9 @@ def references_tool(
 
     # Format output
     method_note = " (grep-based)" if used_grep else " (LSP)"
-    formatted_lines = [f"Found {len(locations)} references to '{symbol}'{method_note}:\n"]
+    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}")

agent_server/langchain/tools/resource_tools.py

@@ -46,7 +46,7 @@ def _build_file_size_command(files: List[str]) -> str:
     """
     if not files:
         return ""
-    
+
     # Use stat with format that works on both macOS and Linux
     # macOS: stat -f "%z %N"
     # Linux: stat -c "%s %n"
@@ -62,10 +62,10 @@ def _build_dataframe_check_code(dataframes: List[str]) -> str:
     """
     if not dataframes:
         return ""
-    
+
     df_checks = []
     for df_name in dataframes:
-        df_checks.append(f'''
+        df_checks.append(f"""
 try:
     _df = {df_name}
     _info = {{
@@ -79,14 +79,14 @@ try:
 except NameError:
     _info = {{"name": "{df_name}", "exists": False}}
 _results.append(_info)
-''')
-    
-    code = f'''
+""")
+
+    code = f"""
 import json
 _results = []
 {chr(10).join(df_checks)}
 print(json.dumps(_results))
-'''
+"""
     return code.strip()
 
 
@@ -137,20 +137,20 @@ def check_resource_tool(
         response["execution_result"] = execution_result
         response["status"] = "complete"
         response["message"] = "Resource check completed"
-        
+
         # Parse the execution result
         if isinstance(execution_result, dict):
             response["success"] = execution_result.get("success", False)
-            
+
             # System resources
             response["system"] = execution_result.get("system", {})
-            
+
             # File sizes
             response["files"] = execution_result.get("files", [])
-            
+
             # DataFrame info
             response["dataframes"] = execution_result.get("dataframes", [])
-            
+
             if "error" in execution_result:
                 response["error"] = execution_result["error"]