Use temporary files for editor tests

Author: peteretelej

src/config.py

@@ -1,5 +1,6 @@
 import os
 from dataclasses import dataclass
+from pathlib import Path
 
 
 @dataclass
@@ -16,7 +17,9 @@ class Config:
     context_lines: int = int(os.getenv("LARGEFILE_CONTEXT_LINES", "2"))
 
     streaming_chunk_size: int = int(os.getenv("LARGEFILE_STREAMING_CHUNK_SIZE", "8192"))
-    backup_dir: str = os.getenv("LARGEFILE_BACKUP_DIR", ".largefile_backups")
+    backup_dir: str = os.getenv(
+        "LARGEFILE_BACKUP_DIR", str(Path.home() / ".largefile" / "backups")
+    )
 
     enable_tree_sitter: bool = (
         os.getenv("LARGEFILE_ENABLE_TREE_SITTER", "true").lower() == "true"

src/mcp_schemas.py

@@ -131,7 +131,7 @@ def get_tool_schemas() -> list[types.Tool]:
 
 def register_tool_handlers(server, tools_module):
     """Register tool handlers with the MCP server."""
-    
+
     @server.list_tools()
     async def list_tools() -> list[types.Tool]:
         """List available tools."""
@@ -151,4 +151,4 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
         else:
             raise ValueError(f"Unknown tool: {name}")
 
-        return [types.TextContent(type="text", text=str(result))]
+        return [types.TextContent(type="text", text=str(result))]

src/server.py

@@ -22,4 +22,4 @@ async def main() -> None:
     async with stdio_server() as (read_stream, write_stream):
         await server.run(
             read_stream, write_stream, server.create_initialization_options()
-        )
+        )

src/tree_parser.py

@@ -48,18 +48,23 @@ def get_language_parser(file_extension: str) -> Any | None:
         language_capsule = None
         if language_name == "python":
             import tree_sitter_python
+
             language_capsule = tree_sitter_python.language()
         elif language_name == "javascript":
             import tree_sitter_javascript
+
             language_capsule = tree_sitter_javascript.language()
         elif language_name == "typescript":
             import tree_sitter_typescript
+
             language_capsule = tree_sitter_typescript.language_typescript()
         elif language_name == "rust":
             import tree_sitter_rust
+
             language_capsule = tree_sitter_rust.language()
         elif language_name == "go":
             import tree_sitter_go
+
             language_capsule = tree_sitter_go.language()
         else:
             return None

src/utils.py

@@ -55,73 +55,3 @@ def format_file_size(size_bytes: int) -> str:
         return f"{size_bytes / (1024 * 1024):.1f} MB"
     else:
         return f"{size_bytes / (1024 * 1024 * 1024):.1f} GB"
-
-
-def detect_file_strategy(file_size: int) -> str:
-    """Detect the best file access strategy based on size.
-
-    This is a convenience function that matches the logic in file_access.py
-
-    Args:
-        file_size: File size in bytes
-
-    Returns:
-        Strategy name: "memory", "mmap", or "streaming"
-    """
-    if file_size < config.memory_threshold:
-        return "memory"
-    elif file_size < config.mmap_threshold:
-        return "mmap"
-    else:
-        return "streaming"
-
-
-def split_long_lines(content: str, max_length: int | None = None) -> str:
-    """Split long lines in content for better display.
-
-    Args:
-        content: Text content to process
-        max_length: Maximum line length (defaults to config.max_line_length)
-
-    Returns:
-        Content with long lines split
-    """
-    if max_length is None:
-        max_length = config.max_line_length
-
-    lines = content.splitlines()
-    result_lines = []
-
-    for line in lines:
-        if len(line) <= max_length:
-            result_lines.append(line)
-        else:
-            # Split long line into chunks
-            for i in range(0, len(line), max_length):
-                chunk = line[i : i + max_length]
-                if i + max_length < len(line):
-                    chunk += " \\"  # Continuation indicator
-                result_lines.append(chunk)
-
-    return "\n".join(result_lines)
-
-
-def count_file_stats(content: str) -> dict[str, int]:
-    """Count basic statistics about file content.
-
-    Args:
-        content: File content to analyze
-
-    Returns:
-        Dictionary with line_count, char_count, long_lines_count
-    """
-    lines = content.splitlines()
-    line_count = len(lines)
-    char_count = len(content)
-    long_lines_count = sum(1 for line in lines if is_long_line(line))
-
-    return {
-        "line_count": line_count,
-        "char_count": char_count,
-        "long_lines_count": long_lines_count,
-    }

tests/integration/test_codebase_workflows.py

@@ -5,7 +5,7 @@
 
 from pathlib import Path
 
-from src.tools import get_overview, search_content, read_content, edit_content
+from src.tools import edit_content, get_overview, read_content, search_content
 
 
 class TestCodebaseWorkflows:
@@ -17,172 +17,170 @@ def test_data_dir(self):
 
     def test_web_framework_patterns_comparison(self):
         """Compare patterns between Django and Laravel web frameworks.
-        
-        Scenario: Developer migrating from Django to Laravel needs to 
+
+        Scenario: Developer migrating from Django to Laravel needs to
         understand model patterns and validation approaches.
         """
         django_models = self.test_data_dir / "python" / "django-models.py"
         laravel_model = self.test_data_dir / "php" / "laravel-model.php"
-        
+
         # Get overview of both frameworks
         django_overview = get_overview(str(django_models))
         laravel_overview = get_overview(str(laravel_model))
-        
+
         assert django_overview["line_count"] > 0
         assert laravel_overview["line_count"] > 0
-        
+
         # Search for model patterns
         django_models_search = search_content(str(django_models), "class", fuzzy=False)
         laravel_models_search = search_content(str(laravel_model), "class", fuzzy=False)
-        
+
         assert django_models_search["total_matches"] > 0
         assert laravel_models_search["total_matches"] > 0
-        
+
         # Search for validation patterns
         django_validation = search_content(str(django_models), "valid", fuzzy=True)
         laravel_validation = search_content(str(laravel_model), "valid", fuzzy=True)
-        
+
         # At least one should have validation patterns
-        total_validation = django_validation["total_matches"] + laravel_validation["total_matches"]
+        total_validation = (
+            django_validation["total_matches"] + laravel_validation["total_matches"]
+        )
         assert total_validation >= 0
 
     def test_large_javascript_codebase_navigation(self):
         """Navigate large JavaScript utility library effectively.
-        
+
         Scenario: Developer needs to understand specific utility functions
         in the Lodash library (532KB file).
         """
         lodash_file = self.test_data_dir / "javascript" / "lodash-utility.js"
-        
+
         if not lodash_file.exists():
             return  # Skip if file doesn't exist
-            
+
         # Get overview - should use mmap strategy for this size
         overview = get_overview(str(lodash_file))
         assert overview["file_size"] > 500_000  # 532KB file
         assert overview["line_count"] > 1000
-        
+
         # Search for common utility functions
         function_search = search_content(str(lodash_file), "function", max_results=10)
         assert function_search["total_matches"] > 0
-        
+
         # Test performance with specific function search
         map_search = search_content(str(lodash_file), "map", fuzzy=True, max_results=5)
         assert map_search["total_matches"] >= 0
 
     def test_cross_language_async_patterns(self):
         """Find async patterns across different programming languages.
-        
+
         Scenario: Developer wants to understand async patterns across
         JavaScript, Python, Go, and C# codebases.
         """
         files = [
             self.test_data_dir / "javascript" / "lodash-utility.js",
-            self.test_data_dir / "python" / "django-models.py", 
+            self.test_data_dir / "python" / "django-models.py",
             self.test_data_dir / "go" / "docker-daemon.go",
-            self.test_data_dir / "csharp" / "aspnet-controller.cs"
+            self.test_data_dir / "csharp" / "aspnet-controller.cs",
         ]
-        
+
         async_patterns_found = 0
         for file_path in files:
             if file_path.exists():
                 result = search_content(str(file_path), "async", fuzzy=True)
                 async_patterns_found += result["total_matches"]
-        
+
         # Should find some async patterns across languages
         assert async_patterns_found >= 0
 
     def test_rust_serialization_code_analysis(self):
         """Analyze Rust serialization library code structure.
-        
-        Scenario: Developer learning Rust needs to understand 
+
+        Scenario: Developer learning Rust needs to understand
         serialization patterns in the Serde library.
         """
         serde_file = self.test_data_dir / "rust" / "serde-derive.rs"
-        
+
         if not serde_file.exists():
             return  # Skip if file doesn't exist
-            
+
         overview = get_overview(str(serde_file))
         assert overview["line_count"] > 0
-        
+
         # Search for Rust-specific patterns
         impl_search = search_content(str(serde_file), "impl", fuzzy=False)
         struct_search = search_content(str(serde_file), "struct", fuzzy=False)
-        
+
         # Should find some Rust patterns
         rust_patterns = impl_search["total_matches"] + struct_search["total_matches"]
         assert rust_patterns > 0
 
     def test_spring_java_application_navigation(self):
         """Navigate Java Spring application code.
-        
-        Scenario: Developer needs to understand Spring Boot 
+
+        Scenario: Developer needs to understand Spring Boot
         application structure and annotations.
         """
         spring_file = self.test_data_dir / "java" / "spring-application.java"
-        
+
         overview = get_overview(str(spring_file))
         assert overview["file_size"] > 0
-        
+
         # Search for Spring annotations and patterns
         annotation_search = search_content(str(spring_file), "@", fuzzy=False)
         class_search = search_content(str(spring_file), "class", fuzzy=False)
-        
+
         assert annotation_search["total_matches"] >= 0
         assert class_search["total_matches"] >= 0
 
     def test_code_search_and_context_extraction(self):
         """Test targeted code search with context extraction.
-        
+
         Scenario: Developer needs to find specific method implementations
         with surrounding context for understanding.
         """
         vscode_extension = self.test_data_dir / "typescript" / "vscode-extension.ts"
-        
+
         if not vscode_extension.exists():
             return  # Skip if file doesn't exist
-            
+
         # Search for function definitions with context
-        function_results = search_content(str(vscode_extension), "function", context_lines=3)
-        
+        function_results = search_content(
+            str(vscode_extension), "function", context_lines=3
+        )
+
         for result in function_results["results"][:3]:  # Check first 3 results
             assert "context_before" in result
             assert "context_after" in result
             assert "line_number" in result
-            
+
             # Read the specific function with more context
             line_num = result["line_number"]
             detailed_content = read_content(
-                str(vscode_extension), 
-                line_num, 
-                mode="lines"
+                str(vscode_extension), line_num, mode="lines"
             )
             assert "content" in detailed_content
 
     def test_safe_code_editing_preview(self):
         """Test safe code editing with preview mode.
-        
+
         Scenario: Developer wants to preview code changes before applying
         them to ensure no unintended modifications.
         """
         # Use a small file for editing tests
         spring_file = self.test_data_dir / "java" / "spring-application.java"
-        
+
         # Test search and replace in preview mode
         result = edit_content(
-            str(spring_file),
-            "class",
-            "public class", 
-            preview=True,
-            fuzzy=False
+            str(spring_file), "class", "public class", preview=True, fuzzy=False
         )
-        
+
         assert "success" in result
         assert "preview" in result
         assert "changes_made" in result
-        
+
         # Verify preview mode doesn't actually modify file
         if result["success"]:
             assert result["preview"] is True
-            assert "backup_created" not in result  # No backup in preview mode
+            assert "backup_created" not in result  # No backup in preview mode