auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/common/terminal_paste/demo.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Demo script for terminal_paste module functionality.
+
+This script demonstrates how the terminal_paste module works:
+1. Simulates paste events by saving content to files
+2. Shows placeholder resolution
+3. Demonstrates cleanup functionality
+"""
+
+import os
+import sys
+from autocoder.common.terminal_paste import (
+    PasteManager, 
+    resolve_paste_placeholders
+)
+from autocoder.common.terminal_paste.paste_handler import (
+    cleanup_old_pastes,
+    list_paste_files
+)
+
+
+def demo_basic_functionality():
+    """Demonstrate basic paste functionality."""
+    print("=== Terminal Paste Module Demo ===\n")
+    
+    # Initialize paste manager
+    pm = PasteManager()
+    print(f"Paste directory: {pm.paste_dir}")
+    
+    # Simulate saving some paste content
+    print("\n1. Saving paste content...")
+    content1 = """def hello_world():
+    print("Hello, World!")
+    return "success"
+"""
+    
+    content2 = """# This is a markdown example
+## Features
+- Feature 1
+- Feature 2
+- Feature 3
+"""
+    
+    file_id1 = pm.save_paste(content1)
+    file_id2 = pm.save_paste(content2)
+    
+    print(f"   Saved Python code as: {file_id1}")
+    print(f"   Saved Markdown as: {file_id2}")
+    
+    # Show placeholder resolution
+    print("\n2. Demonstrating placeholder resolution...")
+    test_command = f"/coding Please review this code: [{file_id1}] and update the documentation: [{file_id2}]"
+    print(f"   Original command: {test_command}")
+    
+    resolved_command = resolve_paste_placeholders(test_command)
+    print(f"   Resolved command: {resolved_command}")
+    
+    # List all paste files
+    print("\n3. Listing all paste files...")
+    paste_files = list_paste_files()
+    for i, paste_file in enumerate(paste_files, 1):
+        print(f"   {i}. {paste_file}")
+    
+    # Read back content
+    print("\n4. Reading back content...")
+    read_content1 = pm.read_paste(file_id1)
+    print(f"   Content from {file_id1}:")
+    if read_content1:
+        print(f"   {repr(read_content1[:50])}...")
+    else:
+        print("   Content not found")
+    
+    # Cleanup demonstration
+    print("\n5. Cleanup demonstration...")
+    print(f"   Files before cleanup: {len(paste_files)}")
+    cleaned_count = cleanup_old_pastes(max_age_hours=0)  # Clean all files
+    print(f"   Files cleaned: {cleaned_count}")
+    
+    remaining_files = list_paste_files()
+    print(f"   Files after cleanup: {len(remaining_files)}")
+
+
+def demo_error_handling():
+    """Demonstrate error handling."""
+    print("\n=== Error Handling Demo ===\n")
+    
+    pm = PasteManager()
+    
+    # Try to read non-existent file
+    print("1. Reading non-existent file...")
+    non_existent = pm.read_paste("pasted-nonexistent12345")
+    print(f"   Result: {non_existent}")
+    
+    # Try to resolve invalid placeholder
+    print("\n2. Resolving invalid placeholder...")
+    invalid_text = "Command with [pasted-invalidid] placeholder"
+    resolved = resolve_paste_placeholders(invalid_text)
+    print(f"   Original: {invalid_text}")
+    print(f"   Resolved: {resolved}")
+
+
+def demo_integration_example():
+    """Show how this would integrate with chat_auto_coder.py."""
+    print("\n=== Integration Example ===\n")
+    
+    # Simulate what happens in chat_auto_coder.py
+    pm = PasteManager()
+    
+    # User pastes some content (simulated)
+    pasted_content = """SELECT users.name, COUNT(orders.id) as order_count
+FROM users 
+LEFT JOIN orders ON users.id = orders.user_id 
+WHERE users.created_at > '2023-01-01'
+GROUP BY users.id, users.name
+ORDER BY order_count DESC;"""
+    
+    # Save the paste (this would happen in the paste handler)
+    file_id = pm.save_paste(pasted_content)
+    print(f"User pastes SQL query, saved as: {file_id}")
+    
+    # User types command with placeholder (what they see in terminal)
+    user_input = f"/coding Please optimize this SQL query: [{file_id}]"
+    print(f"User types: {user_input}")
+    
+    # Before processing, resolve placeholders (happens in main loop)
+    resolved_input = resolve_paste_placeholders(user_input)
+    print(f"System processes: {resolved_input}")
+    
+    print("\nThis way, the user sees a clean command line, but the system gets the full content!")
+
+
+if __name__ == "__main__":
+    try:
+        demo_basic_functionality()
+        demo_error_handling()
+        demo_integration_example()
+        print("\n=== Demo Complete ===")
+    except KeyboardInterrupt:
+        print("\n\nDemo interrupted by user.")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\nDemo failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1) 

autocoder/common/terminal_paste/demo_paste_functionality.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+演示新的粘贴功能
+
+这个脚本展示了如何使用新的粘贴处理功能:
+1. Ctrl+P 粘贴多行内容并自动保存为文件
+2. 占位符自动解析为实际内容
+"""
+
+import os
+import tempfile
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.clipboard import ClipboardData
+from autocoder.common.terminal_paste import register_paste_handler, resolve_paste_placeholders
+
+
+def demo_paste_functionality():
+    """演示粘贴功能的完整流程"""
+    print("🎯 Terminal Paste 功能演示")
+    print("=" * 50)
+    
+    # 创建键绑定
+    kb = KeyBindings()
+    register_paste_handler(kb)
+    
+    print("✅ 粘贴处理器已注册")
+    print("📋 使用说明:")
+    print("   - 复制多行文本到剪贴板")
+    print("   - 按 Ctrl+P 粘贴 (多行内容会保存为文件)")
+    print("   - 按 Ctrl+V 正常粘贴 (单行内容)")
+    print("   - 输入 'quit' 退出演示")
+    print()
+    
+    # 创建 PromptSession
+    session = PromptSession(
+        key_bindings=kb
+        # 注意：bracketed paste 通过 Keys.BracketedPaste 绑定处理
+    )
+    
+    while True:
+        try:
+            # 获取用户输入
+            user_input = session.prompt("📝 请输入命令 (或按 Ctrl+P 粘贴): ")
+            
+            if user_input.lower() in ['quit', 'exit', 'q']:
+                print("👋 演示结束")
+                break
+            
+            # 解析占位符
+            resolved_input = resolve_paste_placeholders(user_input)
+            
+            # 显示结果
+            if resolved_input != user_input:
+                print("🔄 占位符已解析:")
+                print(f"   原始输入: {user_input}")
+                print(f"   解析后: {resolved_input}")
+            else:
+                print(f"📤 您输入了: {resolved_input}")
+            
+            print()
+            
+        except KeyboardInterrupt:
+            print("\n👋 演示结束")
+            break
+        except Exception as e:
+            print(f"❌ 错误: {e}")
+
+
+def create_sample_clipboard_content():
+    """创建示例剪贴板内容用于测试"""
+    sample_content = """def hello_world():
+    print("Hello, World!")
+    return "success"
+
+if __name__ == "__main__":
+    result = hello_world()
+    print(f"Result: {result}")"""
+    
+    print("📋 示例多行内容:")
+    print(sample_content)
+    print()
+    print("💡 提示: 复制上面的代码，然后在演示中按 Ctrl+P 粘贴")
+    print()
+
+
+if __name__ == "__main__":
+    print("🚀 开始 Terminal Paste 功能演示")
+    print()
+    
+    # 显示示例内容
+    create_sample_clipboard_content()
+    
+    # 运行演示
+    demo_paste_functionality() 

autocoder/common/terminal_paste/paste_handler.py

@@ -0,0 +1,200 @@
+"""Terminal paste event handler and placeholder resolver."""
+
+import re
+from typing import Optional, Callable
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.application import get_app
+from prompt_toolkit.clipboard import ClipboardData
+from prompt_toolkit.keys import Keys
+from .paste_manager import PasteManager
+
+
+# Global paste manager instance
+_paste_manager: Optional[PasteManager] = None
+
+# 占位符正则表达式，匹配 [pasted-<uuid>] 格式（32位十六进制，无连字符）
+PLACEHOLDER_PATTERN = re.compile(r"\[pasted-([0-9a-f]{32})\]")
+
+
+def get_paste_manager() -> PasteManager:
+    """Get or create global paste manager instance."""
+    global _paste_manager
+    if _paste_manager is None:
+        _paste_manager = PasteManager()
+    return _paste_manager
+
+
+def register_paste_handler(kb: KeyBindings) -> None:
+    """Register paste handler with prompt_toolkit key bindings.
+    
+    Args:
+        kb: KeyBindings instance to register with
+        
+    Note:
+        This function sets up a custom paste handler that intercepts multi-line
+        paste operations and saves them to files with placeholder replacement.
+        
+        Supports multiple paste methods:
+        - Bracketed paste (automatic detection of pasted content)
+        - Ctrl+V (standard paste shortcut)
+        - Ctrl+P (legacy binding)
+        - Cmd+V (Mac paste shortcut, mapped as Meta+V)
+    """
+    
+    def paste_handler_impl(event):
+        """Handle paste operations with file saving for multi-line content."""
+        try:
+            # Get the current application
+            app = event.app
+            
+            # Get clipboard content
+            clipboard_data = app.clipboard.get_data()
+            if not clipboard_data:
+                return
+                
+            text = clipboard_data.text
+            if not text:
+                return
+            
+            # Check if it's multi-line content (more than 1 line)
+            lines = text.splitlines()
+            if len(lines) > 1:
+                # Save multi-line content to file and insert placeholder
+                paste_manager = get_paste_manager()
+                file_id = paste_manager.save_paste(text)
+                
+                # Create placeholder - file_id already contains "pasted-" prefix
+                placeholder = f"[{file_id}]"
+                
+                # Insert placeholder instead of actual content
+                event.current_buffer.insert_text(placeholder)                
+            else:
+                # For single-line content, just paste normally
+                event.current_buffer.insert_text(text)
+                
+        except Exception as e:
+            print(f"\033[91m✗ Error in paste handler: {e}\033[0m")
+            # Fall back to normal paste behavior
+            try:
+                clipboard_data = event.app.clipboard.get_data()
+                if clipboard_data and clipboard_data.text:
+                    event.current_buffer.insert_text(clipboard_data.text)
+            except:
+                pass
+    
+    # Bind to bracketed paste event (most reliable for all paste operations)
+    @kb.add(Keys.BracketedPaste)
+    def bracketed_paste_handler(event):
+        """Handle bracketed paste events (automatic paste detection)."""
+        try:
+            # For bracketed paste, the pasted text is directly available in event.data
+            text = event.data
+            if not text:
+                return
+            
+            # Check if it's multi-line content (more than 1 line)
+            lines = text.splitlines()
+            if len(lines) > 1:
+                # Save multi-line content to file and insert placeholder
+                paste_manager = get_paste_manager()
+                file_id = paste_manager.save_paste(text)
+                
+                # Create placeholder - file_id already contains "pasted-" prefix
+                placeholder = f"[{file_id}]"
+                
+                # Insert placeholder instead of actual content
+                event.current_buffer.insert_text(placeholder)                
+            else:
+                # For single-line content, just paste normally
+                event.current_buffer.insert_text(text)
+                
+        except Exception as e:
+            print(f"\033[91m✗ Error in bracketed paste handler: {e}\033[0m")
+            # Fall back to inserting the text directly
+            try:
+                if hasattr(event, 'data') and event.data:
+                    event.current_buffer.insert_text(event.data)
+            except:
+                pass
+    
+    # Bind to standard paste shortcuts as backup
+    @kb.add('c-v')  # Ctrl+V (standard paste)
+    def ctrl_v_paste_handler(event):
+        """Handle Ctrl+V paste events."""
+        paste_handler_impl(event)
+    
+    @kb.add('c-p')  # Ctrl+P (legacy binding)
+    def ctrl_p_paste_handler(event):
+        """Handle Ctrl+P paste events (legacy)."""
+        paste_handler_impl(event)
+    
+    # For Mac users: Cmd+V is often mapped as Meta+V in terminals
+    @kb.add('escape', 'v')  # Meta+V (often mapped from Cmd+V on Mac)
+    def meta_v_paste_handler(event):
+        """Handle Meta+V paste events (Mac Cmd+V equivalent)."""
+        paste_handler_impl(event)
+
+
+def resolve_paste_placeholders(text: str) -> str:
+    """Resolve paste placeholders in text to actual content.
+    
+    Args:
+        text: Input text that may contain placeholders
+        
+    Returns:
+        Text with placeholders replaced by actual content
+    """
+    if not text or "[pasted-" not in text:
+        return text
+        
+    paste_manager = get_paste_manager()
+    
+    def replace_placeholder(match) -> str:
+        """Replace a single placeholder with its content."""
+        uuid_part = match.group(1)  # Extract UUID from [pasted-<uuid>]
+        file_id = f"pasted-{uuid_part}"  # Reconstruct full file_id
+        
+        try:
+            content = paste_manager.read_paste(file_id)
+            if content is not None:
+                return content
+            else:
+                # File not found, keep placeholder for debugging
+                print(f"\033[93m⚠ Paste file not found: {file_id}\033[0m")
+                return match.group(0)
+        except Exception as e:
+            print(f"\033[91m✗ Error reading paste file: {e}\033[0m")
+            return match.group(0)
+    
+    # Replace all placeholders in the text
+    resolved_text = PLACEHOLDER_PATTERN.sub(replace_placeholder, text)
+    
+    # Show user if any replacements were made
+    if resolved_text != text:
+        placeholder_count = len(PLACEHOLDER_PATTERN.findall(text))
+        print(f"\033[92m✓ Resolved {placeholder_count} paste placeholder(s)\033[0m")
+    
+    return resolved_text
+
+
+def cleanup_old_pastes(max_age_hours: int = 24) -> int:
+    """Clean up old paste files.
+    
+    Args:
+        max_age_hours: Maximum age in hours for paste files
+        
+    Returns:
+        Number of files cleaned up
+    """
+    paste_manager = get_paste_manager()
+    return paste_manager.cleanup_old_pastes(max_age_hours)
+
+
+def list_paste_files() -> list[str]:
+    """List all paste file IDs.
+    
+    Returns:
+        List of paste file IDs
+    """
+    paste_manager = get_paste_manager()
+    return paste_manager.list_pastes() 

autocoder/common/terminal_paste/paste_manager.py

@@ -0,0 +1,118 @@
+"""Paste manager for handling paste file operations."""
+
+import os
+import uuid
+from typing import Optional
+from pathlib import Path
+
+
+class PasteManager:
+    """Manager for handling paste file operations."""
+    
+    def __init__(self, base_dir: Optional[str] = None):
+        """Initialize paste manager.
+        
+        Args:
+            base_dir: Base directory for paste files. If None, uses current working directory.
+        """
+        self.base_dir = base_dir or os.getcwd()
+        self.paste_dir = os.path.join(self.base_dir, ".auto-coder", "pastes")
+        self._ensure_paste_dir()
+    
+    def _ensure_paste_dir(self) -> None:
+        """Ensure paste directory exists."""
+        os.makedirs(self.paste_dir, exist_ok=True)
+    
+    def save_paste(self, content: str) -> str:
+        """Save paste content to file and return file ID.
+        
+        Args:
+            content: Content to save
+            
+        Returns:
+            File ID (without path)
+        """
+        file_id = f"pasted-{uuid.uuid4().hex}"
+        file_path = os.path.join(self.paste_dir, file_id)
+        
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            return file_id
+        except Exception as e:
+            raise RuntimeError(f"Failed to save paste content: {e}")
+    
+    def read_paste(self, file_id: str) -> Optional[str]:
+        """Read paste content from file.
+        
+        Args:
+            file_id: File ID to read
+            
+        Returns:
+            File content or None if file not found
+        """
+        # Handle both "pasted-<uuid>" and just "<uuid>" formats
+        if not file_id.startswith("pasted-"):
+            file_id = f"pasted-{file_id}"
+            
+        file_path = os.path.join(self.paste_dir, file_id)
+        
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                return f.read()
+        except FileNotFoundError:
+            return None
+        except Exception as e:
+            raise RuntimeError(f"Failed to read paste file {file_id}: {e}")
+    
+    def cleanup_old_pastes(self, max_age_hours: int = 24) -> int:
+        """Clean up old paste files.
+        
+        Args:
+            max_age_hours: Maximum age in hours for paste files
+            
+        Returns:
+            Number of files cleaned up
+        """
+        import time
+        
+        if not os.path.exists(self.paste_dir):
+            return 0
+            
+        current_time = time.time()
+        max_age_seconds = max_age_hours * 3600
+        cleaned_count = 0
+        
+        try:
+            for filename in os.listdir(self.paste_dir):
+                if filename.startswith("pasted-"):
+                    file_path = os.path.join(self.paste_dir, filename)
+                    if os.path.isfile(file_path):
+                        file_age = current_time - os.path.getmtime(file_path)
+                        if file_age > max_age_seconds:
+                            os.remove(file_path)
+                            cleaned_count += 1
+        except Exception as e:
+            raise RuntimeError(f"Failed to cleanup old pastes: {e}")
+            
+        return cleaned_count
+    
+    def list_pastes(self) -> list[str]:
+        """List all paste file IDs.
+        
+        Returns:
+            List of paste file IDs
+        """
+        if not os.path.exists(self.paste_dir):
+            return []
+            
+        try:
+            files = []
+            for filename in os.listdir(self.paste_dir):
+                if filename.startswith("pasted-") and os.path.isfile(
+                    os.path.join(self.paste_dir, filename)
+                ):
+                    files.append(filename)
+            return sorted(files)
+        except Exception as e:
+            raise RuntimeError(f"Failed to list paste files: {e}") 

autocoder/common/terminal_paste/tests/__init__.py

@@ -0,0 +1 @@
+"""Test module for terminal_paste."""