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

agent_server/langchain/tools/file_utils.py

@@ -0,0 +1,334 @@
+"""
+File Utilities for LangChain Agent
+
+Provides utility functions for file operations:
+- perform_string_replacement: String replacement with occurrence validation
+- compute_unified_diff: Generate unified diff between before/after content
+- count_diff_changes: Count additions/deletions from diff
+- format_content_with_line_numbers: Format file content with line numbers (cat -n style)
+- check_empty_content: Check if content is empty and return warning message
+"""
+
+import difflib
+from typing import List, Optional, Tuple, Union
+
+# Constants for file reading (aligned with DeepAgents)
+EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents"
+MAX_LINE_LENGTH = 10000  # Chunk lines longer than this
+LINE_NUMBER_WIDTH = 6  # Width for line number padding
+
+
+def check_empty_content(content: str) -> Optional[str]:
+    """
+    Check if content is empty and return warning message.
+
+    Args:
+        content: Content to check
+
+    Returns:
+        Warning message if empty, None otherwise
+    """
+    if not content or content.strip() == "":
+        return EMPTY_CONTENT_WARNING
+    return None
+
+
+def format_content_with_line_numbers(
+    content: Union[str, List[str]],
+    start_line: int = 1,
+) -> str:
+    """
+    Format file content with line numbers (cat -n style).
+
+    Chunks lines longer than MAX_LINE_LENGTH with continuation markers (e.g., 5.1, 5.2).
+
+    Args:
+        content: File content as string or list of lines
+        start_line: Starting line number (default: 1)
+
+    Returns:
+        Formatted content with line numbers and continuation markers
+    """
+    if isinstance(content, str):
+        lines = content.split("\n")
+        # Remove trailing empty line if content ends with newline
+        if lines and lines[-1] == "":
+            lines = lines[:-1]
+    else:
+        lines = content
+
+    result_lines = []
+    for i, line in enumerate(lines):
+        line_num = i + start_line
+
+        if len(line) <= MAX_LINE_LENGTH:
+            result_lines.append(f"{line_num:{LINE_NUMBER_WIDTH}d}\t{line}")
+        else:
+            # Split long line into chunks with continuation markers
+            num_chunks = (len(line) + MAX_LINE_LENGTH - 1) // MAX_LINE_LENGTH
+            for chunk_idx in range(num_chunks):
+                start = chunk_idx * MAX_LINE_LENGTH
+                end = min(start + MAX_LINE_LENGTH, len(line))
+                chunk = line[start:end]
+                if chunk_idx == 0:
+                    # First chunk: use normal line number
+                    result_lines.append(f"{line_num:{LINE_NUMBER_WIDTH}d}\t{chunk}")
+                else:
+                    # Continuation chunks: use decimal notation (e.g., 5.1, 5.2)
+                    continuation_marker = f"{line_num}.{chunk_idx}"
+                    result_lines.append(
+                        f"{continuation_marker:>{LINE_NUMBER_WIDTH}}\t{chunk}"
+                    )
+
+    return "\n".join(result_lines)
+
+
+def format_read_response(
+    content: str,
+    offset: int = 0,
+    limit: int = 500,
+) -> str:
+    """
+    Format file content for read response with line numbers and pagination.
+
+    Args:
+        content: Full file content
+        offset: Line offset (0-indexed)
+        limit: Maximum number of lines to return
+
+    Returns:
+        Formatted content with line numbers, or error/warning message
+    """
+    # Check for empty content
+    empty_msg = check_empty_content(content)
+    if empty_msg:
+        return empty_msg
+
+    lines = content.splitlines()
+    total_lines = len(lines)
+
+    # Validate offset
+    if offset >= total_lines:
+        return f"Error: Line offset {offset} exceeds file length ({total_lines} lines)"
+
+    # Apply pagination
+    start_idx = offset
+    end_idx = min(start_idx + limit, total_lines)
+    selected_lines = lines[start_idx:end_idx]
+
+    # Format with line numbers
+    formatted = format_content_with_line_numbers(
+        selected_lines, start_line=start_idx + 1
+    )
+
+    # Add pagination info if truncated
+    if end_idx < total_lines:
+        remaining = total_lines - end_idx
+        formatted += f"\n\n[... {remaining} more lines. Use offset={end_idx} to continue reading]"
+
+    return formatted
+
+
+def _normalize_whitespace(text: str) -> str:
+    """Normalize line endings and trailing whitespace per line."""
+    lines = text.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    return "\n".join(line.rstrip() for line in lines)
+
+
+def perform_string_replacement(
+    content: str,
+    old_string: str,
+    new_string: str,
+    replace_all: bool = False,
+) -> Union[Tuple[str, int], str]:
+    """
+    Perform string replacement with occurrence validation.
+
+    Includes fallback strategies for more robust matching:
+    1. Exact match
+    2. Strip leading/trailing newlines from old_string
+    3. Normalize whitespace (line endings, trailing spaces)
+
+    Args:
+        content: Original file content
+        old_string: String to replace
+        new_string: Replacement string
+        replace_all: Whether to replace all occurrences
+
+    Returns:
+        Tuple of (new_content, occurrences) on success,
+        or error message string on failure
+    """
+    # Strategy 1: Exact match
+    occurrences = content.count(old_string)
+
+    if occurrences == 0:
+        # Strategy 2: Strip leading/trailing newlines from old_string
+        stripped_old = old_string.strip("\n")
+        occurrences = content.count(stripped_old)
+        if occurrences > 0:
+            old_string = stripped_old
+            # Also strip new_string's leading/trailing newlines to match
+            new_string = new_string.strip("\n")
+
+    if occurrences == 0:
+        # Strategy 3: Normalize whitespace (line endings, trailing spaces)
+        normalized_content = _normalize_whitespace(content)
+        normalized_old = _normalize_whitespace(old_string.strip("\n"))
+        occurrences = normalized_content.count(normalized_old)
+
+        if occurrences > 0:
+            # Find the original text in content that matches normalized version
+            # We need to do replacement on the normalized content first
+            normalized_new = _normalize_whitespace(new_string.strip("\n"))
+            if occurrences > 1 and not replace_all:
+                preview = (
+                    old_string[:50] + "..." if len(old_string) > 50 else old_string
+                )
+                return (
+                    f"Error: String '{preview}' appears {occurrences} times in file. "
+                    "Use replace_all=True to replace all instances, "
+                    "or provide a more specific string with surrounding context."
+                )
+            # Replace on normalized content, then return
+            new_content = normalized_content.replace(normalized_old, normalized_new)
+            return new_content, occurrences
+
+    if occurrences == 0:
+        # All strategies failed
+        preview = old_string[:100] + "..." if len(old_string) > 100 else old_string
+        return f"Error: String not found in file: '{preview}'"
+
+    if occurrences > 1 and not replace_all:
+        preview = old_string[:50] + "..." if len(old_string) > 50 else old_string
+        return (
+            f"Error: String '{preview}' appears {occurrences} times in file. "
+            "Use replace_all=True to replace all instances, "
+            "or provide a more specific string with surrounding context."
+        )
+
+    new_content = content.replace(old_string, new_string)
+    return new_content, occurrences
+
+
+def compute_unified_diff(
+    before: str,
+    after: str,
+    filepath: str,
+    max_lines: int = 100,
+    context_lines: int = 3,
+) -> Union[str, None]:
+    """
+    Compute a unified diff between before and after content.
+
+    Args:
+        before: Original content
+        after: New content
+        filepath: Path for display in diff headers
+        max_lines: Maximum number of diff lines (None for unlimited)
+        context_lines: Number of context lines around changes (default 3)
+
+    Returns:
+        Unified diff string or None if no changes
+    """
+    before_lines = before.splitlines()
+    after_lines = after.splitlines()
+
+    diff_lines = list(
+        difflib.unified_diff(
+            before_lines,
+            after_lines,
+            fromfile=f"{filepath} (before)",
+            tofile=f"{filepath} (after)",
+            lineterm="",
+            n=context_lines,
+        )
+    )
+
+    if not diff_lines:
+        return None
+
+    if max_lines and len(diff_lines) > max_lines:
+        truncated = diff_lines[: max_lines - 1]
+        truncated.append(
+            f"... [{len(diff_lines) - max_lines + 1} more lines truncated]"
+        )
+        return "\n".join(truncated)
+
+    return "\n".join(diff_lines)
+
+
+def count_diff_changes(diff: str) -> Tuple[int, int]:
+    """
+    Count additions and deletions from unified diff.
+
+    Args:
+        diff: Unified diff string
+
+    Returns:
+        Tuple of (additions, deletions) line counts
+    """
+    if not diff:
+        return 0, 0
+
+    additions = sum(
+        1
+        for line in diff.splitlines()
+        if line.startswith("+") and not line.startswith("+++")
+    )
+    deletions = sum(
+        1
+        for line in diff.splitlines()
+        if line.startswith("-") and not line.startswith("---")
+    )
+    return additions, deletions
+
+
+def build_edit_preview(
+    original_content: str,
+    old_string: str,
+    new_string: str,
+    replace_all: bool,
+    filepath: str,
+) -> dict:
+    """
+    Build a preview for edit_file operation including diff.
+
+    Args:
+        original_content: Current file content
+        old_string: String to replace
+        new_string: Replacement string
+        replace_all: Whether to replace all occurrences
+        filepath: File path for display
+
+    Returns:
+        Dict with diff, occurrences, and change counts
+    """
+    result = perform_string_replacement(
+        original_content, old_string, new_string, replace_all
+    )
+
+    if isinstance(result, str):
+        # Error case
+        return {
+            "success": False,
+            "error": result,
+            "diff": None,
+            "occurrences": 0,
+            "lines_added": 0,
+            "lines_removed": 0,
+        }
+
+    new_content, occurrences = result
+    diff = compute_unified_diff(original_content, new_content, filepath)
+    additions, deletions = count_diff_changes(diff) if diff else (0, 0)
+
+    return {
+        "success": True,
+        "error": None,
+        "diff": diff,
+        "occurrences": occurrences,
+        "lines_added": additions,
+        "lines_removed": deletions,
+        "new_content": new_content,
+    }

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

@@ -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 execute_command_tool with grep 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 += " (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 execute_command_tool with grep.
+
+    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 execute_command_tool with grep 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/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"]