Add files using upload-large-folder tool

projects/ui/DeepCode/cli/__init__.py

@@ -0,0 +1,18 @@
+"""
+CLI Module for DeepCode Agent
+DeepCode智能体CLI模块
+
+包含以下组件 / Contains the following components:
+- cli_app: CLI应用主程序 / CLI application main program
+- cli_interface: CLI界面组件 / CLI interface components
+- cli_launcher: CLI启动器 / CLI launcher
+"""
+
+__version__ = "1.0.0"
+__author__ = "DeepCode Team - Data Intelligence Lab @ HKU"
+
+from .cli_app import main as cli_main
+from .cli_interface import CLIInterface
+from .cli_launcher import main as launcher_main
+
+__all__ = ["cli_main", "CLIInterface", "launcher_main"]

projects/ui/DeepCode/cli/cli_app.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+DeepCode - CLI Application Main Program
+深度代码 - CLI应用主程序
+
+🧬 Open-Source Code Agent by Data Intelligence Lab @ HKU
+⚡ Revolutionizing research reproducibility through collaborative AI
+"""
+
+import os
+import sys
+import asyncio
+import time
+import json
+
+# 禁止生成.pyc文件
+os.environ["PYTHONDONTWRITEBYTECODE"] = "1"
+
+# 添加项目根目录到路径
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.insert(0, parent_dir)
+
+# 导入MCP应用和工作流
+
+from cli.workflows import CLIWorkflowAdapter
+from cli.cli_interface import CLIInterface, Colors
+
+
+class CLIApp:
+    """CLI应用主类 - 升级版智能体编排引擎"""
+
+    def __init__(self):
+        self.cli = CLIInterface()
+        self.workflow_adapter = CLIWorkflowAdapter(cli_interface=self.cli)
+        self.app = None  # Will be initialized by workflow adapter
+        self.logger = None
+        self.context = None
+        # Document segmentation configuration
+        self.segmentation_config = {"enabled": True, "size_threshold_chars": 50000}
+
+    async def initialize_mcp_app(self):
+        """初始化MCP应用 - 使用工作流适配器"""
+        # Workflow adapter will handle MCP initialization
+        return await self.workflow_adapter.initialize_mcp_app()
+
+    async def cleanup_mcp_app(self):
+        """清理MCP应用 - 使用工作流适配器"""
+        await self.workflow_adapter.cleanup_mcp_app()
+
+    def update_segmentation_config(self):
+        """Update document segmentation configuration in mcp_agent.config.yaml"""
+        import yaml
+        import os
+
+        config_path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            "mcp_agent.config.yaml",
+        )
+
+        try:
+            # Read current config
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+
+            # Update document segmentation settings
+            if "document_segmentation" not in config:
+                config["document_segmentation"] = {}
+
+            config["document_segmentation"]["enabled"] = self.segmentation_config[
+                "enabled"
+            ]
+            config["document_segmentation"]["size_threshold_chars"] = (
+                self.segmentation_config["size_threshold_chars"]
+            )
+
+            # Write updated config
+            with open(config_path, "w", encoding="utf-8") as f:
+                yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
+
+            self.cli.print_status(
+                "📄 Document segmentation configuration updated", "success"
+            )
+
+        except Exception as e:
+            self.cli.print_status(
+                f"⚠️ Failed to update segmentation config: {str(e)}", "warning"
+            )
+
+    async def process_input(self, input_source: str, input_type: str):
+        """处理输入源（URL或文件）- 使用升级版智能体编排引擎"""
+        try:
+            # Update segmentation configuration before processing
+            self.update_segmentation_config()
+
+            self.cli.print_separator()
+            self.cli.print_status(
+                "🚀 Starting intelligent agent orchestration...", "processing"
+            )
+
+            # 显示处理阶段（根据配置决定）
+            self.cli.display_processing_stages(0, self.cli.enable_indexing)
+
+            # 使用工作流适配器进行处理
+            result = await self.workflow_adapter.process_input_with_orchestration(
+                input_source=input_source,
+                input_type=input_type,
+                enable_indexing=self.cli.enable_indexing,
+            )
+
+            if result["status"] == "success":
+                # 显示完成状态
+                final_stage = 8 if self.cli.enable_indexing else 5
+                self.cli.display_processing_stages(
+                    final_stage, self.cli.enable_indexing
+                )
+                self.cli.print_status(
+                    "🎉 Agent orchestration completed successfully!", "complete"
+                )
+
+                # 显示结果
+                self.display_results(
+                    result.get("analysis_result", ""),
+                    result.get("download_result", ""),
+                    result.get("repo_result", ""),
+                    result.get("pipeline_mode", "comprehensive"),
+                )
+            else:
+                self.cli.print_status(
+                    f"❌ Processing failed: {result.get('error', 'Unknown error')}",
+                    "error",
+                )
+
+            # 添加到历史记录
+            self.cli.add_to_history(input_source, result)
+
+            return result
+
+        except Exception as e:
+            error_msg = str(e)
+            self.cli.print_error_box("Agent Orchestration Error", error_msg)
+            self.cli.print_status(f"Error during orchestration: {error_msg}", "error")
+
+            # 添加错误到历史记录
+            error_result = {"status": "error", "error": error_msg}
+            self.cli.add_to_history(input_source, error_result)
+
+            return error_result
+
+    def display_results(
+        self,
+        analysis_result: str,
+        download_result: str,
+        repo_result: str,
+        pipeline_mode: str = "comprehensive",
+    ):
+        """显示处理结果"""
+        self.cli.print_results_header()
+
+        # 显示流水线模式
+        if pipeline_mode == "chat":
+            mode_display = "💬 Chat Planning Mode"
+        elif pipeline_mode == "comprehensive":
+            mode_display = "🧠 Comprehensive Mode"
+        else:
+            mode_display = "⚡ Optimized Mode"
+        print(
+            f"{Colors.BOLD}{Colors.PURPLE}🤖 PIPELINE MODE: {mode_display}{Colors.ENDC}"
+        )
+        self.cli.print_separator("─", 79, Colors.PURPLE)
+
+        print(f"{Colors.BOLD}{Colors.OKCYAN}📊 ANALYSIS PHASE RESULTS:{Colors.ENDC}")
+        self.cli.print_separator("─", 79, Colors.CYAN)
+
+        # 尝试解析并格式化分析结果
+        try:
+            if analysis_result.strip().startswith("{"):
+                parsed_analysis = json.loads(analysis_result)
+                print(json.dumps(parsed_analysis, indent=2, ensure_ascii=False))
+            else:
+                print(
+                    analysis_result[:1000] + "..."
+                    if len(analysis_result) > 1000
+                    else analysis_result
+                )
+        except Exception:
+            print(
+                analysis_result[:1000] + "..."
+                if len(analysis_result) > 1000
+                else analysis_result
+            )
+
+        print(f"\n{Colors.BOLD}{Colors.PURPLE}📥 DOWNLOAD PHASE RESULTS:{Colors.ENDC}")
+        self.cli.print_separator("─", 79, Colors.PURPLE)
+        print(
+            download_result[:1000] + "..."
+            if len(download_result) > 1000
+            else download_result
+        )
+
+        print(
+            f"\n{Colors.BOLD}{Colors.GREEN}⚙️  IMPLEMENTATION PHASE RESULTS:{Colors.ENDC}"
+        )
+        self.cli.print_separator("─", 79, Colors.GREEN)
+        print(repo_result[:1000] + "..." if len(repo_result) > 1000 else repo_result)
+
+        # 尝试提取生成的代码目录信息
+        if "Code generated in:" in repo_result:
+            code_dir = (
+                repo_result.split("Code generated in:")[-1].strip().split("\n")[0]
+            )
+            print(
+                f"\n{Colors.BOLD}{Colors.YELLOW}📁 Generated Code Directory: {Colors.ENDC}{code_dir}"
+            )
+
+        # 显示处理完成的工作流阶段
+        print(
+            f"\n{Colors.BOLD}{Colors.OKCYAN}🔄 COMPLETED WORKFLOW STAGES:{Colors.ENDC}"
+        )
+
+        if pipeline_mode == "chat":
+            stages = [
+                "🚀 Engine Initialization",
+                "💬 Requirements Analysis",
+                "🏗️ Workspace Setup",
+                "📝 Implementation Plan Generation",
+                "⚙️ Code Implementation",
+            ]
+        else:
+            stages = [
+                "📄 Document Processing",
+                "🔍 Reference Analysis",
+                "📋 Plan Generation",
+                "📦 Repository Download",
+                "🗂️ Codebase Indexing",
+                "⚙️ Code Implementation",
+            ]
+
+        for stage in stages:
+            print(f"  ✅ {stage}")
+
+        self.cli.print_separator()
+
+    async def run_interactive_session(self):
+        """运行交互式会话"""
+        # 清屏并显示启动界面
+        self.cli.clear_screen()
+        self.cli.print_logo()
+        self.cli.print_welcome_banner()
+
+        # 初始化MCP应用
+        await self.initialize_mcp_app()
+
+        try:
+            # 主交互循环
+            while self.cli.is_running:
+                self.cli.create_menu()
+                choice = self.cli.get_user_input()
+
+                if choice in ["q", "quit", "exit"]:
+                    self.cli.print_goodbye()
+                    break
+
+                elif choice in ["u", "url"]:
+                    url = self.cli.get_url_input()
+                    if url:
+                        await self.process_input(url, "url")
+
+                elif choice in ["f", "file"]:
+                    file_path = self.cli.upload_file_gui()
+                    if file_path:
+                        await self.process_input(f"file://{file_path}", "file")
+
+                elif choice in ["t", "chat", "text"]:
+                    chat_input = self.cli.get_chat_input()
+                    if chat_input:
+                        await self.process_input(chat_input, "chat")
+
+                elif choice in ["h", "history"]:
+                    self.cli.show_history()
+
+                elif choice in ["c", "config", "configure"]:
+                    # Sync current segmentation config from CLI interface
+                    self.segmentation_config["enabled"] = self.cli.segmentation_enabled
+                    self.segmentation_config["size_threshold_chars"] = (
+                        self.cli.segmentation_threshold
+                    )
+
+                    self.cli.show_configuration_menu()
+
+                    # Sync back from CLI interface after configuration changes
+                    self.segmentation_config["enabled"] = self.cli.segmentation_enabled
+                    self.segmentation_config["size_threshold_chars"] = (
+                        self.cli.segmentation_threshold
+                    )
+
+                else:
+                    self.cli.print_status(
+                        "Invalid choice. Please select U, F, T, C, H, or Q.", "warning"
+                    )
+
+                # 询问是否继续
+                if self.cli.is_running and choice in ["u", "f", "t", "chat", "text"]:
+                    if not self.cli.ask_continue():
+                        self.cli.is_running = False
+                        self.cli.print_status("Session ended by user", "info")
+
+        except KeyboardInterrupt:
+            print(f"\n{Colors.WARNING}⚠️  Process interrupted by user{Colors.ENDC}")
+        except Exception as e:
+            print(f"\n{Colors.FAIL}❌ Unexpected error: {str(e)}{Colors.ENDC}")
+        finally:
+            # 清理资源
+            await self.cleanup_mcp_app()
+
+
+async def main():
+    """主函数"""
+    start_time = time.time()
+
+    try:
+        # 创建并运行CLI应用
+        app = CLIApp()
+        await app.run_interactive_session()
+
+    except KeyboardInterrupt:
+        print(f"\n{Colors.WARNING}⚠️  Application interrupted by user{Colors.ENDC}")
+    except Exception as e:
+        print(f"\n{Colors.FAIL}❌ Application error: {str(e)}{Colors.ENDC}")
+    finally:
+        end_time = time.time()
+        print(
+            f"\n{Colors.BOLD}{Colors.CYAN}⏱️  Total runtime: {end_time - start_time:.2f} seconds{Colors.ENDC}"
+        )
+
+        # 清理缓存文件
+        print(f"{Colors.YELLOW}🧹 Cleaning up cache files...{Colors.ENDC}")
+        if os.name == "nt":  # Windows
+            os.system(
+                "powershell -Command \"Get-ChildItem -Path . -Filter '__pycache__' -Recurse -Directory | Remove-Item -Recurse -Force\" 2>nul"
+            )
+        else:  # Unix/Linux/macOS
+            os.system('find . -type d -name "__pycache__" -exec rm -r {} + 2>/dev/null')
+
+        print(
+            f"{Colors.OKGREEN}✨ Goodbye! Thanks for using DeepCode CLI! ✨{Colors.ENDC}"
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

projects/ui/DeepCode/cli/cli_interface.py

@@ -0,0 +1,786 @@
+#!/usr/bin/env python3
+"""
+Enhanced CLI Interface Module for DeepCode
+增强版CLI界面模块 - 专为DeepCode设计
+"""
+
+import os
+import time
+import platform
+from typing import Optional
+
+
+class Colors:
+    """ANSI color codes for terminal styling"""
+
+    HEADER = "\033[95m"
+    OKBLUE = "\033[94m"
+    OKCYAN = "\033[96m"
+    OKGREEN = "\033[92m"
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+
+    # Gradient colors
+    PURPLE = "\033[35m"
+    MAGENTA = "\033[95m"
+    BLUE = "\033[34m"
+    CYAN = "\033[36m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+
+
+class CLIInterface:
+    """Enhanced CLI interface with modern styling for DeepCode"""
+
+    def __init__(self):
+        self.uploaded_file = None
+        self.is_running = True
+        self.processing_history = []
+        self.enable_indexing = True  # Default configuration
+        self.segmentation_enabled = True  # Default to smart segmentation
+        self.segmentation_threshold = 50000  # Default threshold
+
+        # Check tkinter availability for file dialogs
+        self.tkinter_available = True
+        try:
+            import tkinter as tk
+
+            # Test if tkinter can create a window
+            test_root = tk.Tk()
+            test_root.withdraw()
+            test_root.destroy()
+        except Exception:
+            self.tkinter_available = False
+
+    def clear_screen(self):
+        """Clear terminal screen"""
+        os.system("cls" if os.name == "nt" else "clear")
+
+    def print_logo(self):
+        """Print enhanced ASCII logo for DeepCode CLI"""
+        logo = f"""
+{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                                                                               ║
+║  {Colors.BOLD}{Colors.MAGENTA}██████╗ ███████╗███████╗██████╗  ██████╗ ██████╗ ██████╗ ███████╗{Colors.CYAN}               ║
+║  {Colors.BOLD}{Colors.PURPLE}██╔══██╗██╔════╝██╔════╝██╔══██╗██╔════╝██╔═══██╗██╔══██╗██╔════╝{Colors.CYAN}               ║
+║  {Colors.BOLD}{Colors.BLUE}██║  ██║█████╗  █████╗  ██████╔╝██║     ██║   ██║██║  ██║█████╗  {Colors.CYAN}               ║
+║  {Colors.BOLD}{Colors.OKBLUE}██║  ██║██╔══╝  ██╔══╝  ██╔═══╝ ██║     ██║   ██║██║  ██║██╔══╝  {Colors.CYAN}               ║
+║  {Colors.BOLD}{Colors.OKCYAN}██████╔╝███████╗███████╗██║     ╚██████╗╚██████╔╝██████╔╝███████╗{Colors.CYAN}               ║
+║  {Colors.BOLD}{Colors.GREEN}╚═════╝ ╚══════╝╚══════╝╚═╝      ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝{Colors.CYAN}               ║
+║                                                                               ║
+║  {Colors.BOLD}{Colors.GREEN}🧬 OPEN-SOURCE CODE AGENT • DATA INTELLIGENCE LAB @ HKU 🚀           {Colors.CYAN}║
+║  {Colors.BOLD}{Colors.GREEN}⚡ REVOLUTIONIZING RESEARCH REPRODUCIBILITY ⚡                      {Colors.CYAN}║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(logo)
+
+    def print_welcome_banner(self):
+        """Print enhanced welcome banner"""
+        banner = f"""
+{Colors.BOLD}{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                             WELCOME TO DEEPCODE CLI                          ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║  {Colors.YELLOW}Open-Source Code Agent | Data Intelligence Lab @ HKU | MIT License        {Colors.CYAN}║
+║  {Colors.GREEN}Status: Ready | Engine: Multi-Agent Architecture Initialized               {Colors.CYAN}║
+║  {Colors.PURPLE}Mission: Revolutionizing Research Reproducibility                         {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.BOLD}{Colors.OKCYAN}💎 CORE CAPABILITIES:{Colors.ENDC}                                                      {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Automated Paper-to-Code Reproduction                                {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Collaborative Multi-Agent Architecture                             {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Intelligent Code Implementation & Validation                       {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Future Vision: One Sentence → Complete Codebase                   {Colors.CYAN}║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(banner)
+
+    def print_separator(self, char="═", length=79, color=Colors.CYAN):
+        """Print a styled separator line"""
+        print(f"{color}{char * length}{Colors.ENDC}")
+
+    def print_status(self, message: str, status_type: str = "info"):
+        """Print status message with appropriate styling"""
+        status_styles = {
+            "success": f"{Colors.OKGREEN}✅",
+            "error": f"{Colors.FAIL}❌",
+            "warning": f"{Colors.WARNING}⚠️ ",
+            "info": f"{Colors.OKBLUE}ℹ️ ",
+            "processing": f"{Colors.YELLOW}⏳",
+            "upload": f"{Colors.PURPLE}📁",
+            "download": f"{Colors.CYAN}📥",
+            "analysis": f"{Colors.MAGENTA}🔍",
+            "implementation": f"{Colors.GREEN}⚙️ ",
+            "complete": f"{Colors.OKGREEN}🎉",
+        }
+
+        icon = status_styles.get(status_type, status_styles["info"])
+        timestamp = time.strftime("%H:%M:%S")
+        print(
+            f"[{Colors.BOLD}{timestamp}{Colors.ENDC}] {icon} {Colors.BOLD}{message}{Colors.ENDC}"
+        )
+
+    def create_menu(self):
+        """Create enhanced interactive menu"""
+        # Display current configuration
+        pipeline_mode = "🧠 COMPREHENSIVE" if self.enable_indexing else "⚡ OPTIMIZED"
+        index_status = "✅ Enabled" if self.enable_indexing else "🔶 Disabled"
+        segmentation_mode = (
+            "📄 SMART" if self.segmentation_enabled else "📋 TRADITIONAL"
+        )
+
+        menu = f"""
+{Colors.BOLD}{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                                MAIN MENU                                      ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║  {Colors.OKGREEN}🌐 [U] Process URL       {Colors.CYAN}│  {Colors.PURPLE}📁 [F] Upload File    {Colors.CYAN}│  {Colors.MAGENTA}💬 [T] Chat Input{Colors.CYAN}    ║
+║  {Colors.OKCYAN}⚙️  [C] Configure        {Colors.CYAN}│  {Colors.YELLOW}📊 [H] History        {Colors.CYAN}│  {Colors.FAIL}❌ [Q] Quit{Colors.CYAN}         ║
+║                                                                               ║
+║  {Colors.BOLD}🤖 Current Pipeline Mode: {pipeline_mode}{Colors.CYAN}                          ║
+║  {Colors.BOLD}🗂️  Codebase Indexing: {index_status}{Colors.CYAN}                                    ║
+║  {Colors.BOLD}📄 Document Processing: {segmentation_mode}{Colors.CYAN}                               ║
+║                                                                               ║
+║  {Colors.YELLOW}📝 URL Processing:{Colors.CYAN}                                                         ║
+║  {Colors.YELLOW}   ▶ Enter research paper URL (arXiv, IEEE, ACM, etc.)                    {Colors.CYAN}║
+║  {Colors.YELLOW}   ▶ Supports direct PDF links and academic paper pages                   {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.PURPLE}📁 File Processing:{Colors.CYAN}                                                        ║
+║  {Colors.PURPLE}   ▶ Upload PDF, DOCX, PPTX, HTML, or TXT files                          {Colors.CYAN}║
+║  {Colors.PURPLE}   ▶ Intelligent file format detection and processing                     {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.MAGENTA}💬 Chat Input:{Colors.CYAN}                                                           ║
+║  {Colors.MAGENTA}   ▶ Describe your coding requirements in natural language                {Colors.CYAN}║
+║  {Colors.MAGENTA}   ▶ AI generates implementation plan and code automatically             {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.OKCYAN}🔄 Processing Pipeline:{Colors.CYAN}                                                    ║
+║  {Colors.OKCYAN}   ▶ Intelligent agent orchestration → Code synthesis                     {Colors.CYAN}║
+║  {Colors.OKCYAN}   ▶ Multi-agent coordination with progress tracking                     {Colors.CYAN}║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(menu)
+
+    def get_user_input(self):
+        """Get user input with styled prompt"""
+        print(f"\n{Colors.BOLD}{Colors.OKCYAN}➤ Your choice: {Colors.ENDC}", end="")
+        return input().strip().lower()
+
+    def upload_file_gui(self) -> Optional[str]:
+        """Enhanced file upload interface with better error handling"""
+        if not self.tkinter_available:
+            self.print_status(
+                "GUI file dialog not available - using manual input", "warning"
+            )
+            return self._get_manual_file_path()
+
+        def select_file():
+            try:
+                import tkinter as tk
+                from tkinter import filedialog
+
+                root = tk.Tk()
+                root.withdraw()
+                root.attributes("-topmost", True)
+
+                file_types = [
+                    ("Research Papers", "*.pdf;*.docx;*.doc"),
+                    ("PDF Files", "*.pdf"),
+                    ("Word Documents", "*.docx;*.doc"),
+                    ("PowerPoint Files", "*.pptx;*.ppt"),
+                    ("HTML Files", "*.html;*.htm"),
+                    ("Text Files", "*.txt;*.md"),
+                    ("All Files", "*.*"),
+                ]
+
+                if platform.system() == "Darwin":
+                    file_types = [
+                        ("Research Papers", ".pdf .docx .doc"),
+                        ("PDF Files", ".pdf"),
+                        ("Word Documents", ".docx .doc"),
+                        ("PowerPoint Files", ".pptx .ppt"),
+                        ("HTML Files", ".html .htm"),
+                        ("Text Files", ".txt .md"),
+                        ("All Files", ".*"),
+                    ]
+
+                file_path = filedialog.askopenfilename(
+                    title="Select Research File - DeepCode CLI",
+                    filetypes=file_types,
+                    initialdir=os.getcwd(),
+                )
+
+                root.destroy()
+                return file_path
+
+            except Exception as e:
+                self.print_status(f"File dialog error: {str(e)}", "error")
+                return self._get_manual_file_path()
+
+        self.print_status("Opening file browser dialog...", "upload")
+        file_path = select_file()
+
+        if file_path:
+            self.print_status(
+                f"File selected: {os.path.basename(file_path)}", "success"
+            )
+            return file_path
+        else:
+            self.print_status("No file selected", "warning")
+            return None
+
+    def _get_manual_file_path(self) -> Optional[str]:
+        """Get file path through manual input with validation"""
+        self.print_separator("─", 79, Colors.YELLOW)
+        print(f"{Colors.BOLD}{Colors.YELLOW}📁 Manual File Path Input{Colors.ENDC}")
+        print(
+            f"{Colors.CYAN}Please enter the full path to your research paper file:{Colors.ENDC}"
+        )
+        print(
+            f"{Colors.CYAN}Supported formats: PDF, DOCX, PPTX, HTML, TXT, MD{Colors.ENDC}"
+        )
+        self.print_separator("─", 79, Colors.YELLOW)
+
+        while True:
+            print(f"\n{Colors.BOLD}{Colors.OKCYAN}📂 File path: {Colors.ENDC}", end="")
+            file_path = input().strip()
+
+            if not file_path:
+                self.print_status(
+                    "Empty path entered. Please try again or press Ctrl+C to cancel.",
+                    "warning",
+                )
+                continue
+
+            file_path = os.path.expanduser(file_path)
+            file_path = os.path.abspath(file_path)
+
+            if not os.path.exists(file_path):
+                self.print_status(f"File not found: {file_path}", "error")
+                retry = (
+                    input(f"{Colors.YELLOW}Try again? (y/n): {Colors.ENDC}")
+                    .strip()
+                    .lower()
+                )
+                if retry != "y":
+                    return None
+                continue
+
+            if not os.path.isfile(file_path):
+                self.print_status(f"Path is not a file: {file_path}", "error")
+                continue
+
+            supported_extensions = {
+                ".pdf",
+                ".docx",
+                ".doc",
+                ".pptx",
+                ".ppt",
+                ".html",
+                ".htm",
+                ".txt",
+                ".md",
+            }
+            file_ext = os.path.splitext(file_path)[1].lower()
+
+            if file_ext not in supported_extensions:
+                self.print_status(f"Unsupported file format: {file_ext}", "warning")
+                proceed = (
+                    input(f"{Colors.YELLOW}Process anyway? (y/n): {Colors.ENDC}")
+                    .strip()
+                    .lower()
+                )
+                if proceed != "y":
+                    continue
+
+            self.print_status(
+                f"File validated: {os.path.basename(file_path)}", "success"
+            )
+            return file_path
+
+    def get_url_input(self) -> str:
+        """Enhanced URL input with validation"""
+        self.print_separator("─", 79, Colors.GREEN)
+        print(f"{Colors.BOLD}{Colors.GREEN}🌐 URL Input Interface{Colors.ENDC}")
+        print(
+            f"{Colors.CYAN}Enter a research paper URL from supported platforms:{Colors.ENDC}"
+        )
+        print(
+            f"{Colors.CYAN}• arXiv (arxiv.org)        • IEEE Xplore (ieeexplore.ieee.org){Colors.ENDC}"
+        )
+        print(
+            f"{Colors.CYAN}• ACM Digital Library      • SpringerLink • Nature • Science{Colors.ENDC}"
+        )
+        print(
+            f"{Colors.CYAN}• Direct PDF links         • Academic publisher websites{Colors.ENDC}"
+        )
+        self.print_separator("─", 79, Colors.GREEN)
+
+        while True:
+            print(f"\n{Colors.BOLD}{Colors.OKCYAN}🔗 URL: {Colors.ENDC}", end="")
+            url = input().strip()
+
+            if not url:
+                self.print_status(
+                    "Empty URL entered. Please try again or press Ctrl+C to cancel.",
+                    "warning",
+                )
+                continue
+
+            if not url.startswith(("http://", "https://")):
+                self.print_status("URL must start with http:// or https://", "error")
+                retry = (
+                    input(f"{Colors.YELLOW}Try again? (y/n): {Colors.ENDC}")
+                    .strip()
+                    .lower()
+                )
+                if retry != "y":
+                    return ""
+                continue
+
+            academic_domains = [
+                "arxiv.org",
+                "ieeexplore.ieee.org",
+                "dl.acm.org",
+                "link.springer.com",
+                "nature.com",
+                "science.org",
+                "scholar.google.com",
+                "researchgate.net",
+                "semanticscholar.org",
+            ]
+
+            is_academic = any(domain in url.lower() for domain in academic_domains)
+            if not is_academic and not url.lower().endswith(".pdf"):
+                self.print_status(
+                    "URL doesn't appear to be from a known academic platform", "warning"
+                )
+                proceed = (
+                    input(f"{Colors.YELLOW}Process anyway? (y/n): {Colors.ENDC}")
+                    .strip()
+                    .lower()
+                )
+                if proceed != "y":
+                    continue
+
+            self.print_status(f"URL validated: {url}", "success")
+            return url
+
+    def get_chat_input(self) -> str:
+        """Enhanced chat input interface for coding requirements"""
+        self.print_separator("─", 79, Colors.PURPLE)
+        print(f"{Colors.BOLD}{Colors.PURPLE}💬 Chat Input Interface{Colors.ENDC}")
+        print(
+            f"{Colors.CYAN}Describe your coding requirements in natural language.{Colors.ENDC}"
+        )
+        print(
+            f"{Colors.CYAN}Our AI will analyze your needs and generate a comprehensive implementation plan.{Colors.ENDC}"
+        )
+        self.print_separator("─", 79, Colors.PURPLE)
+
+        # Display examples to help users
+        print(f"\n{Colors.BOLD}{Colors.YELLOW}💡 Examples:{Colors.ENDC}")
+        print(f"{Colors.CYAN}Academic Research:{Colors.ENDC}")
+        print(
+            "  • 'I need to implement a reinforcement learning algorithm for robotic control'"
+        )
+        print(
+            "  • 'Create a neural network for image classification with attention mechanisms'"
+        )
+        print(f"{Colors.CYAN}Engineering Projects:{Colors.ENDC}")
+        print(
+            "  • 'Develop a web application for project management with user authentication'"
+        )
+        print("  • 'Create a data visualization dashboard for sales analytics'")
+        print(f"{Colors.CYAN}Mixed Projects:{Colors.ENDC}")
+        print(
+            "  • 'Implement a machine learning model with a web interface for real-time predictions'"
+        )
+
+        self.print_separator("─", 79, Colors.PURPLE)
+
+        print(
+            f"\n{Colors.BOLD}{Colors.OKCYAN}✏️  Enter your coding requirements below:{Colors.ENDC}"
+        )
+        print(
+            f"{Colors.YELLOW}(Type your description, press Enter twice when finished, or Ctrl+C to cancel){Colors.ENDC}"
+        )
+
+        lines = []
+        empty_line_count = 0
+
+        while True:
+            try:
+                if len(lines) == 0:
+                    print(f"{Colors.BOLD}> {Colors.ENDC}", end="")
+                else:
+                    print(f"{Colors.BOLD}  {Colors.ENDC}", end="")
+
+                line = input()
+
+                if line.strip() == "":
+                    empty_line_count += 1
+                    if empty_line_count >= 2:
+                        # Two consecutive empty lines means user finished input
+                        break
+                    lines.append("")  # Keep empty line for formatting
+                else:
+                    empty_line_count = 0
+                    lines.append(line)
+
+            except KeyboardInterrupt:
+                print(f"\n{Colors.WARNING}Input cancelled by user{Colors.ENDC}")
+                return ""
+
+        # Join all lines and clean up
+        user_input = "\n".join(lines).strip()
+
+        if not user_input:
+            self.print_status("No input provided", "warning")
+            return ""
+
+        if len(user_input) < 20:
+            self.print_status(
+                "Input too short. Please provide more detailed requirements (at least 20 characters)",
+                "warning",
+            )
+            retry = (
+                input(f"{Colors.YELLOW}Try again? (y/n): {Colors.ENDC}").strip().lower()
+            )
+            if retry == "y":
+                return self.get_chat_input()  # Recursive call for retry
+            return ""
+
+        # Display input summary
+        word_count = len(user_input.split())
+        char_count = len(user_input)
+
+        print(f"\n{Colors.BOLD}{Colors.GREEN}📋 Input Summary:{Colors.ENDC}")
+        print(f"  • {Colors.CYAN}Word count: {word_count}{Colors.ENDC}")
+        print(f"  • {Colors.CYAN}Character count: {char_count}{Colors.ENDC}")
+
+        # Show preview
+        preview = user_input[:200] + "..." if len(user_input) > 200 else user_input
+        print(f"\n{Colors.BOLD}{Colors.CYAN}📄 Preview:{Colors.ENDC}")
+        print(f"{Colors.YELLOW}{preview}{Colors.ENDC}")
+
+        # Confirm with user
+        confirm = (
+            input(
+                f"\n{Colors.BOLD}{Colors.OKCYAN}Proceed with this input? (y/n): {Colors.ENDC}"
+            )
+            .strip()
+            .lower()
+        )
+        if confirm != "y":
+            retry = (
+                input(f"{Colors.YELLOW}Edit input? (y/n): {Colors.ENDC}")
+                .strip()
+                .lower()
+            )
+            if retry == "y":
+                return self.get_chat_input()  # Recursive call for retry
+            return ""
+
+        self.print_status(
+            f"Chat input captured: {word_count} words, {char_count} characters",
+            "success",
+        )
+        return user_input
+
+    def show_progress_bar(self, message: str, duration: float = 2.0):
+        """Show animated progress bar"""
+        print(f"\n{Colors.BOLD}{Colors.CYAN}{message}{Colors.ENDC}")
+
+        bar_length = 50
+        for i in range(bar_length + 1):
+            percent = (i / bar_length) * 100
+            filled = "█" * i
+            empty = "░" * (bar_length - i)
+
+            print(
+                f"\r{Colors.OKGREEN}[{filled}{empty}] {percent:3.0f}%{Colors.ENDC}",
+                end="",
+                flush=True,
+            )
+            time.sleep(duration / bar_length)
+
+        print(f"\n{Colors.OKGREEN}✓ {message} completed{Colors.ENDC}")
+
+    def show_spinner(self, message: str, duration: float = 1.0):
+        """Show spinner animation"""
+        spinner_chars = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+        end_time = time.time() + duration
+
+        print(
+            f"{Colors.BOLD}{Colors.CYAN}{message}... {Colors.ENDC}", end="", flush=True
+        )
+
+        i = 0
+        while time.time() < end_time:
+            print(
+                f"\r{Colors.BOLD}{Colors.CYAN}{message}... {Colors.YELLOW}{spinner_chars[i % len(spinner_chars)]}{Colors.ENDC}",
+                end="",
+                flush=True,
+            )
+            time.sleep(0.1)
+            i += 1
+
+        print(
+            f"\r{Colors.BOLD}{Colors.CYAN}{message}... {Colors.OKGREEN}✓{Colors.ENDC}"
+        )
+
+    def display_processing_stages(
+        self,
+        current_stage: int = 0,
+        enable_indexing: bool = True,
+        chat_mode: bool = False,
+    ):
+        """Display processing pipeline stages with current progress"""
+        if chat_mode:
+            # Chat mode - simplified workflow for user requirements
+            stages = [
+                ("🚀", "Initialize", "Setting up chat engine"),
+                ("💬", "Planning", "Analyzing requirements"),
+                ("🏗️", "Setup", "Creating workspace"),
+                ("📝", "Save Plan", "Saving implementation plan"),
+                ("⚙️", "Implement", "Generating code"),
+            ]
+            pipeline_mode = "CHAT PLANNING"
+        elif enable_indexing:
+            # Full pipeline with all stages
+            stages = [
+                ("🚀", "Initialize", "Setting up AI engine"),
+                ("📊", "Analyze", "Analyzing research content"),
+                ("📥", "Download", "Processing document"),
+                ("📋", "Plan", "Generating code architecture"),
+                ("🔍", "References", "Analyzing references"),
+                ("📦", "Repos", "Downloading repositories"),
+                ("🗂️", "Index", "Building code index"),
+                ("⚙️", "Implement", "Implementing code"),
+            ]
+            pipeline_mode = "COMPREHENSIVE"
+        else:
+            # Fast mode - skip indexing related stages
+            stages = [
+                ("🚀", "Initialize", "Setting up AI engine"),
+                ("📊", "Analyze", "Analyzing research content"),
+                ("📥", "Download", "Processing document"),
+                ("📋", "Plan", "Generating code architecture"),
+                ("⚙️", "Implement", "Implementing code"),
+            ]
+            pipeline_mode = "OPTIMIZED"
+
+        print(
+            f"\n{Colors.BOLD}{Colors.CYAN}📋 {pipeline_mode} PIPELINE STATUS{Colors.ENDC}"
+        )
+        self.print_separator("─", 79, Colors.CYAN)
+
+        for i, (icon, name, desc) in enumerate(stages):
+            if i < current_stage:
+                status = f"{Colors.OKGREEN}✓ COMPLETED{Colors.ENDC}"
+            elif i == current_stage:
+                status = f"{Colors.YELLOW}⏳ IN PROGRESS{Colors.ENDC}"
+            else:
+                status = f"{Colors.CYAN}⏸️  PENDING{Colors.ENDC}"
+
+            print(
+                f"{icon} {Colors.BOLD}{name:<12}{Colors.ENDC} │ {desc:<25} │ {status}"
+            )
+
+        self.print_separator("─", 79, Colors.CYAN)
+
+    def print_results_header(self):
+        """Print results section header"""
+        header = f"""
+{Colors.BOLD}{Colors.OKGREEN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                              PROCESSING RESULTS                              ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(header)
+
+    def print_error_box(self, title: str, error_msg: str):
+        """Print formatted error box"""
+        print(
+            f"\n{Colors.FAIL}╔══════════════════════════════════════════════════════════════╗"
+        )
+        print(f"║ {Colors.BOLD}ERROR: {title:<50}{Colors.FAIL} ║")
+        print("╠══════════════════════════════════════════════════════════════╣")
+
+        words = error_msg.split()
+        lines = []
+        current_line = ""
+
+        for word in words:
+            if len(current_line + word) <= 54:
+                current_line += word + " "
+            else:
+                lines.append(current_line.strip())
+                current_line = word + " "
+        if current_line:
+            lines.append(current_line.strip())
+
+        for line in lines:
+            print(f"║ {line:<56} ║")
+
+        print(
+            f"╚══════════════════════════════════════════════════════════════╝{Colors.ENDC}"
+        )
+
+    def cleanup_cache(self):
+        """清理Python缓存文件 / Clean up Python cache files"""
+        try:
+            self.print_status("Cleaning up cache files...", "info")
+            # 清理__pycache__目录
+            os.system('find . -type d -name "__pycache__" -exec rm -r {} + 2>/dev/null')
+            # 清理.pyc文件
+            os.system('find . -name "*.pyc" -delete 2>/dev/null')
+            self.print_status("Cache cleanup completed", "success")
+        except Exception as e:
+            self.print_status(f"Cache cleanup failed: {e}", "warning")
+
+    def print_goodbye(self):
+        """Print goodbye message"""
+        # 清理缓存文件
+        self.cleanup_cache()
+
+        goodbye = f"""
+{Colors.BOLD}{Colors.CYAN}╔═════════════════════════════════════════════════════���═════════════════════════╗
+║                                GOODBYE                                        ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║  {Colors.OKGREEN}🎉 Thank you for using DeepCode CLI!                                     {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.YELLOW}🧬 Join our community in revolutionizing research reproducibility         {Colors.CYAN}║
+║  {Colors.PURPLE}⚡ Together, we're building the future of automated code generation       {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.OKCYAN}💡 Questions? Contribute to our open-source mission at GitHub             {Colors.CYAN}║
+║  {Colors.GREEN}🧹 Cache files cleaned up for optimal performance                         {Colors.CYAN}║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(goodbye)
+
+    def ask_continue(self) -> bool:
+        """Ask if user wants to continue with another paper"""
+        self.print_separator("─", 79, Colors.YELLOW)
+        print(f"\n{Colors.BOLD}{Colors.YELLOW}🔄 Process another paper?{Colors.ENDC}")
+        choice = input(f"{Colors.OKCYAN}Continue? (y/n): {Colors.ENDC}").strip().lower()
+        return choice in ["y", "yes", "1", "true"]
+
+    def add_to_history(self, input_source: str, result: dict):
+        """Add processing result to history"""
+        entry = {
+            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "input_source": input_source,
+            "status": result.get("status", "unknown"),
+            "result": result,
+        }
+        self.processing_history.append(entry)
+
+    def show_history(self):
+        """Display processing history"""
+        if not self.processing_history:
+            self.print_status("No processing history available", "info")
+            return
+
+        print(f"\n{Colors.BOLD}{Colors.CYAN}📚 PROCESSING HISTORY{Colors.ENDC}")
+        self.print_separator("─", 79, Colors.CYAN)
+
+        for i, entry in enumerate(self.processing_history, 1):
+            status_icon = "✅" if entry["status"] == "success" else "❌"
+            source = entry["input_source"]
+            if len(source) > 50:
+                source = source[:47] + "..."
+
+            print(f"{i}. {status_icon} {entry['timestamp']} | {source}")
+
+        self.print_separator("─", 79, Colors.CYAN)
+
+    def show_configuration_menu(self):
+        """Show configuration options menu"""
+        self.clear_screen()
+
+        # Get segmentation config status
+        segmentation_enabled = getattr(self, "segmentation_enabled", True)
+        segmentation_threshold = getattr(self, "segmentation_threshold", 50000)
+
+        print(f"""
+{Colors.BOLD}{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                           CONFIGURATION MENU                                  ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║                                                                               ║
+║  {Colors.BOLD}🤖 Agent Orchestration Engine Configuration{Colors.CYAN}                             ║
+║                                                                               ║
+║  {Colors.OKCYAN}[1] Pipeline Mode:{Colors.CYAN}                                                        ║
+║      {Colors.BOLD}🧠 Comprehensive Mode{Colors.CYAN} - Full intelligence analysis (Default)         ║
+║         ✓ Research Analysis + Resource Processing                            ║
+║         ✓ Reference Intelligence Discovery                                   ║
+║         ✓ Automated Repository Acquisition                                   ║
+║         ✓ Codebase Intelligence Orchestration                               ║
+║         ✓ Intelligent Code Implementation Synthesis                         ║
+║                                                                               ║
+║      {Colors.BOLD}⚡ Optimized Mode{Colors.CYAN} - Fast processing (Skip indexing)                    ║
+║         ✓ Research Analysis + Resource Processing                            ║
+║         ✓ Code Architecture Synthesis                                        ║
+║         ✓ Intelligent Code Implementation Synthesis                         ║
+║         ✗ Reference Intelligence Discovery (Skipped)                        ║
+║         ✗ Repository Acquisition (Skipped)                                   ║
+║         ✗ Codebase Intelligence Orchestration (Skipped)                     ║
+║                                                                               ║
+║  {Colors.OKCYAN}[2] Document Processing:{Colors.CYAN}                                                   ║
+║      {Colors.BOLD}📄 Smart Segmentation{Colors.CYAN} - Intelligent document analysis (Default)      ║
+║         ✓ Semantic boundary detection                                        ║
+║         ✓ Algorithm integrity preservation                                   ║
+║         ✓ Formula chain recognition                                          ║
+║         ✓ Adaptive character limits                                          ║
+║                                                                               ║
+║      {Colors.BOLD}📋 Traditional Processing{Colors.CYAN} - Full document reading                       ║
+║         ✓ Complete document analysis                                         ║
+║         ✗ Smart segmentation (Disabled)                                      ║
+║                                                                               ║
+║  {Colors.YELLOW}Current Settings:{Colors.CYAN}                                                         ║
+║    Pipeline: {'🧠 Comprehensive Mode' if self.enable_indexing else '⚡ Optimized Mode'}                                          ║
+║    Document: {'📄 Smart Segmentation' if segmentation_enabled else '📋 Traditional Processing'}                                ║
+║    Threshold: {segmentation_threshold} characters                                    ║
+║                                                                               ║
+║  {Colors.OKGREEN}[T] Toggle Pipeline    {Colors.BLUE}[S] Toggle Segmentation    {Colors.FAIL}[B] Back{Colors.CYAN}     ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+""")
+
+        while True:
+            print(
+                f"\n{Colors.BOLD}{Colors.OKCYAN}➤ Configuration choice: {Colors.ENDC}",
+                end="",
+            )
+            choice = input().strip().lower()
+
+            if choice in ["t", "toggle"]:
+                self.enable_indexing = not self.enable_indexing
+                mode = "🧠 Comprehensive" if self.enable_indexing else "⚡ Optimized"
+                self.print_status(f"Pipeline mode switched to: {mode}", "success")
+                time.sleep(1)
+                self.show_configuration_menu()
+                return
+
+            elif choice in ["s", "segmentation"]:
+                current_state = getattr(self, "segmentation_enabled", True)
+                self.segmentation_enabled = not current_state
+                seg_mode = (
+                    "📄 Smart Segmentation"
+                    if self.segmentation_enabled
+                    else "📋 Traditional Processing"
+                )
+                self.print_status(
+                    f"Document processing switched to: {seg_mode}", "success"
+                )
+                time.sleep(1)
+                self.show_configuration_menu()
+                return
+
+            elif choice in ["b", "back"]:
+                return
+
+            else:
+                self.print_status(
+                    "Invalid choice. Please enter 'T', 'S', or 'B'.", "warning"
+                )

projects/ui/DeepCode/cli/cli_launcher.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+DeepCode - CLI Research Engine Launcher
+DeepCode - CLI研究引擎启动器
+
+🧬 Open-Source Code Agent by Data Intelligence Lab @ HKU (CLI Edition)
+⚡ Revolutionizing research reproducibility through collaborative AI via command line
+"""
+
+import sys
+from pathlib import Path
+
+
+def check_dependencies():
+    """检查必要的依赖是否已安装 / Check if necessary dependencies are installed"""
+    import importlib.util
+
+    print("🔍 Checking CLI dependencies...")
+
+    missing_deps = []
+
+    # Check asyncio availability
+    if importlib.util.find_spec("asyncio") is not None:
+        print("✅ Asyncio is available")
+    else:
+        missing_deps.append("asyncio")
+
+    # Check PyYAML availability
+    if importlib.util.find_spec("yaml") is not None:
+        print("✅ PyYAML is installed")
+    else:
+        missing_deps.append("pyyaml")
+
+    # Check Tkinter availability
+    if importlib.util.find_spec("tkinter") is not None:
+        print("✅ Tkinter is available (for file dialogs)")
+    else:
+        print("⚠️  Tkinter not available - file dialogs will use manual input")
+
+    # Check for MCP agent dependencies
+    if importlib.util.find_spec("mcp_agent.app") is not None:
+        print("✅ MCP Agent framework is available")
+    else:
+        missing_deps.append("mcp-agent")
+
+    # Check for workflow dependencies
+    # 添加项目根目录到路径
+    current_dir = Path(__file__).parent
+    project_root = current_dir.parent
+    if str(project_root) not in sys.path:
+        sys.path.insert(0, str(project_root))
+
+    if importlib.util.find_spec("workflows.agent_orchestration_engine") is not None:
+        print("✅ Workflow modules are available")
+    else:
+        print("⚠️  Workflow modules may not be properly configured")
+
+    # Check for CLI components
+    if importlib.util.find_spec("cli.cli_app") is not None:
+        print("✅ CLI application components are available")
+    else:
+        print("❌ CLI application components missing")
+        missing_deps.append("cli-components")
+
+    if missing_deps:
+        print("\n❌ Missing dependencies:")
+        for dep in missing_deps:
+            print(f"   - {dep}")
+        print("\nPlease install missing dependencies using:")
+        print(
+            f"pip install {' '.join([d for d in missing_deps if d != 'cli-components'])}"
+        )
+        if "cli-components" in missing_deps:
+            print(
+                "CLI components appear to be missing - please check the cli/ directory"
+            )
+        return False
+
+    print("✅ All CLI dependencies satisfied")
+    return True
+
+
+def print_banner():
+    """显示CLI启动横幅 / Display CLI startup banner"""
+    banner = """
+╔══════════════════════════════════════════════════════════════╗
+║                                                              ║
+║    🧬 DeepCode - Open-Source Code Agent                      ║
+║                                                              ║
+║    ⚡ DATA INTELLIGENCE LAB @ HKU ⚡                        ║
+║                                                              ║
+║                               ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+"""
+    print(banner)
+
+
+def main():
+    """主函数 / Main function"""
+    print_banner()
+
+    # 检查依赖 / Check dependencies
+    if not check_dependencies():
+        print("\n🚨 Please install missing dependencies and try again.")
+        sys.exit(1)
+
+    # 获取当前脚本目录 / Get current script directory
+    current_dir = Path(__file__).parent
+    project_root = current_dir.parent
+    cli_app_path = current_dir / "cli_app.py"
+
+    # 检查cli_app.py是否存在 / Check if cli_app.py exists
+    if not cli_app_path.exists():
+        print(f"❌ CLI application file not found: {cli_app_path}")
+        print("Please ensure the cli/cli_app.py file exists.")
+        sys.exit(1)
+
+    print(f"\n📁 CLI App location: {cli_app_path}")
+    print("🖥️  Starting DeepCode CLI interface...")
+    print("🚀 Initializing command line application")
+    print("=" * 70)
+    print("💡 Tip: Follow the interactive prompts to process your research")
+    print("🛑 Press Ctrl+C to exit at any time")
+    print("=" * 70)
+
+    # 启动CLI应用 / Launch CLI application
+    try:
+        # 导入并运行CLI应用
+        if str(project_root) not in sys.path:
+            sys.path.insert(0, str(project_root))  # 添加项目根目录到路径
+        from cli.cli_app import main as cli_main
+
+        print("\n🎯 Launching CLI application...")
+
+        # 使用asyncio运行主函数
+        import asyncio
+
+        asyncio.run(cli_main())
+
+    except KeyboardInterrupt:
+        print("\n\n🛑 DeepCode CLI stopped by user")
+        print("Thank you for using DeepCode CLI! 🧬")
+    except ImportError as e:
+        print(f"\n❌ Failed to import CLI application: {e}")
+        print("Please check if all modules are properly installed.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")
+        print("Please check your Python environment and try again.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

projects/ui/DeepCode/cli/main_cli.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""
+DeepCode CLI - Open-Source Code Agent
+深度代码CLI - 开源代码智能体
+
+🧬 Data Intelligence Lab @ HKU
+⚡ Revolutionizing Research Reproducibility through Multi-Agent Architecture
+"""
+
+import os
+import sys
+import asyncio
+import argparse
+
+# 禁止生成.pyc文件
+os.environ["PYTHONDONTWRITEBYTECODE"] = "1"
+
+# 添加项目根目录到路径
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.insert(0, parent_dir)
+
+# 导入CLI应用
+from cli.cli_app import CLIApp, Colors
+
+
+def print_enhanced_banner():
+    """显示增强版启动横幅"""
+    banner = f"""
+{Colors.CYAN}╔══════════════════════════════════════════════════════════════════════════════╗
+║                                                                              ║
+║    {Colors.BOLD}{Colors.MAGENTA}🧬 DeepCode - Open-Source Code Agent{Colors.CYAN}                              ║
+║                                                                              ║
+║    {Colors.BOLD}{Colors.YELLOW}⚡ DATA INTELLIGENCE LAB @ HKU ⚡{Colors.CYAN}                                ║
+║                                                                              ║
+║    Revolutionizing research reproducibility through collaborative AI         ║
+║    Building the future where code is reproduced from natural language       ║
+║                                                                              ║
+║    {Colors.BOLD}{Colors.GREEN}🤖 Key Features:{Colors.CYAN}                                                    ║
+║    • Automated paper-to-code reproduction                                   ║
+║    • Multi-agent collaborative architecture                                 ║
+║    • Open-source and extensible design                                      ║
+║    • Join our growing research community                                    ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+    print(banner)
+
+
+def check_environment():
+    """检查运行环境"""
+    print(f"{Colors.CYAN}🔍 Checking environment...{Colors.ENDC}")
+
+    # 检查Python版本
+    if sys.version_info < (3, 8):
+        print(
+            f"{Colors.FAIL}❌ Python 3.8+ required. Current: {sys.version}{Colors.ENDC}"
+        )
+        return False
+
+    print(f"{Colors.OKGREEN}✅ Python {sys.version.split()[0]} - OK{Colors.ENDC}")
+
+    # 检查必要模块
+    required_modules = [
+        ("asyncio", "Async IO support"),
+        ("pathlib", "Path handling"),
+        ("typing", "Type hints"),
+    ]
+
+    missing_modules = []
+    for module, desc in required_modules:
+        try:
+            __import__(module)
+            print(f"{Colors.OKGREEN}✅ {desc} - OK{Colors.ENDC}")
+        except ImportError:
+            missing_modules.append(module)
+            print(f"{Colors.FAIL}❌ {desc} - Missing{Colors.ENDC}")
+
+    if missing_modules:
+        print(
+            f"{Colors.FAIL}❌ Missing required modules: {', '.join(missing_modules)}{Colors.ENDC}"
+        )
+        return False
+
+    print(f"{Colors.OKGREEN}✅ Environment check passed{Colors.ENDC}")
+    return True
+
+
+def parse_arguments():
+    """解析命令行参数"""
+    parser = argparse.ArgumentParser(
+        description="DeepCode CLI - Open-Source Code Agent by Data Intelligence Lab @ HKU",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=f"""
+{Colors.BOLD}Examples:{Colors.ENDC}
+  {Colors.CYAN}python main_cli.py{Colors.ENDC}                               # Interactive mode
+  {Colors.CYAN}python main_cli.py --file paper.pdf{Colors.ENDC}                # Process file directly
+  {Colors.CYAN}python main_cli.py --url https://...{Colors.ENDC}               # Process URL directly
+  {Colors.CYAN}python main_cli.py --chat "Build a web app..."{Colors.ENDC}     # Process chat requirements
+  {Colors.CYAN}python main_cli.py --optimized{Colors.ENDC}                     # Use optimized mode
+  {Colors.CYAN}python main_cli.py --disable-segmentation{Colors.ENDC}          # Disable document segmentation
+  {Colors.CYAN}python main_cli.py --segmentation-threshold 30000{Colors.ENDC}  # Custom segmentation threshold
+
+{Colors.BOLD}Pipeline Modes:{Colors.ENDC}
+  {Colors.GREEN}Comprehensive{Colors.ENDC}: Full intelligence analysis with indexing
+  {Colors.YELLOW}Optimized{Colors.ENDC}:     Fast processing without indexing
+
+{Colors.BOLD}Document Processing:{Colors.ENDC}
+  {Colors.BLUE}Smart Segmentation{Colors.ENDC}: Intelligent document segmentation for large papers
+  {Colors.MAGENTA}Supported Formats{Colors.ENDC}: PDF, DOCX, DOC, PPT, PPTX, XLS, XLSX, HTML, TXT, MD
+        """,
+    )
+
+    parser.add_argument(
+        "--file", "-f", type=str, help="Process a specific file (PDF, DOCX, TXT, etc.)"
+    )
+
+    parser.add_argument(
+        "--url", "-u", type=str, help="Process a research paper from URL"
+    )
+
+    parser.add_argument(
+        "--chat",
+        "-t",
+        type=str,
+        help="Process coding requirements via chat input (provide requirements as argument)",
+    )
+
+    parser.add_argument(
+        "--optimized",
+        "-o",
+        action="store_true",
+        help="Use optimized mode (skip indexing for faster processing)",
+    )
+
+    parser.add_argument(
+        "--disable-segmentation",
+        action="store_true",
+        help="Disable intelligent document segmentation (use traditional full-document processing)",
+    )
+
+    parser.add_argument(
+        "--segmentation-threshold",
+        type=int,
+        default=50000,
+        help="Document size threshold (characters) to trigger segmentation (default: 50000)",
+    )
+
+    parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Enable verbose output"
+    )
+
+    return parser.parse_args()
+
+
+async def run_direct_processing(app: CLIApp, input_source: str, input_type: str):
+    """直接处理模式（非交互式）"""
+    try:
+        print(
+            f"\n{Colors.BOLD}{Colors.CYAN}🚀 Starting direct processing mode...{Colors.ENDC}"
+        )
+        print(f"{Colors.CYAN}Input: {input_source}{Colors.ENDC}")
+        print(f"{Colors.CYAN}Type: {input_type}{Colors.ENDC}")
+        print(
+            f"{Colors.CYAN}Mode: {'🧠 Comprehensive' if app.cli.enable_indexing else '⚡ Optimized'}{Colors.ENDC}"
+        )
+
+        # 初始化应用
+        init_result = await app.initialize_mcp_app()
+        if init_result["status"] != "success":
+            print(
+                f"{Colors.FAIL}❌ Initialization failed: {init_result['message']}{Colors.ENDC}"
+            )
+            return False
+
+        # 处理输入
+        result = await app.process_input(input_source, input_type)
+
+        if result["status"] == "success":
+            print(
+                f"\n{Colors.BOLD}{Colors.OKGREEN}🎉 Processing completed successfully!{Colors.ENDC}"
+            )
+            return True
+        else:
+            print(
+                f"\n{Colors.BOLD}{Colors.FAIL}❌ Processing failed: {result.get('error', 'Unknown error')}{Colors.ENDC}"
+            )
+            return False
+
+    except Exception as e:
+        print(f"\n{Colors.FAIL}❌ Direct processing error: {str(e)}{Colors.ENDC}")
+        return False
+    finally:
+        await app.cleanup_mcp_app()
+
+
+async def main():
+    """主函数"""
+    # 解析命令行参数
+    args = parse_arguments()
+
+    # 显示横幅
+    print_enhanced_banner()
+
+    # 检查环境
+    if not check_environment():
+        print(
+            f"\n{Colors.FAIL}🚨 Environment check failed. Please fix the issues and try again.{Colors.ENDC}"
+        )
+        sys.exit(1)
+
+    try:
+        # 创建CLI应用
+        app = CLIApp()
+
+        # 设置配置
+        if args.optimized:
+            app.cli.enable_indexing = False
+            print(
+                f"\n{Colors.YELLOW}⚡ Optimized mode enabled - indexing disabled{Colors.ENDC}"
+            )
+        else:
+            print(
+                f"\n{Colors.GREEN}🧠 Comprehensive mode enabled - full intelligence analysis{Colors.ENDC}"
+            )
+
+        # Configure document segmentation settings
+        if hasattr(args, "disable_segmentation") and args.disable_segmentation:
+            print(
+                f"\n{Colors.MAGENTA}📄 Document segmentation disabled - using traditional processing{Colors.ENDC}"
+            )
+            app.segmentation_config = {
+                "enabled": False,
+                "size_threshold_chars": args.segmentation_threshold,
+            }
+        else:
+            print(
+                f"\n{Colors.BLUE}📄 Smart document segmentation enabled (threshold: {args.segmentation_threshold} chars){Colors.ENDC}"
+            )
+            app.segmentation_config = {
+                "enabled": True,
+                "size_threshold_chars": args.segmentation_threshold,
+            }
+
+        # 检查是否为直接处理模式
+        if args.file or args.url or args.chat:
+            if args.file:
+                # 验证文件存在
+                if not os.path.exists(args.file):
+                    print(f"{Colors.FAIL}❌ File not found: {args.file}{Colors.ENDC}")
+                    sys.exit(1)
+                success = await run_direct_processing(app, args.file, "file")
+            elif args.url:
+                success = await run_direct_processing(app, args.url, "url")
+            elif args.chat:
+                # 验证chat输入长度
+                if len(args.chat.strip()) < 20:
+                    print(
+                        f"{Colors.FAIL}❌ Chat input too short. Please provide more detailed requirements (at least 20 characters){Colors.ENDC}"
+                    )
+                    sys.exit(1)
+                success = await run_direct_processing(app, args.chat, "chat")
+
+            sys.exit(0 if success else 1)
+        else:
+            # 交互式模式
+            print(f"\n{Colors.CYAN}🎮 Starting interactive mode...{Colors.ENDC}")
+            await app.run_interactive_session()
+
+    except KeyboardInterrupt:
+        print(f"\n{Colors.WARNING}⚠️  Application interrupted by user{Colors.ENDC}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n{Colors.FAIL}❌ Application errors: {str(e)}{Colors.ENDC}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

projects/ui/DeepCode/config/mcp_tool_definitions.py

@@ -0,0 +1,375 @@
+"""
+MCP工具定义配置模块
+MCP Tool Definitions Configuration Module
+
+将工具定义从主程序逻辑中分离，提供标准化的工具定义格式
+Separate tool definitions from main program logic, providing standardized tool definition format
+
+支持的工具类型：
+- 文件操作工具 (File Operations)
+- 代码执行工具 (Code Execution)
+- 搜索工具 (Search Tools)
+- 项目结构工具 (Project Structure Tools)
+"""
+
+from typing import Dict, List, Any
+
+
+class MCPToolDefinitions:
+    """MCP工具定义管理器"""
+
+    @staticmethod
+    def get_code_implementation_tools() -> List[Dict[str, Any]]:
+        """
+        获取代码实现相关的工具定义
+        Get tool definitions for code implementation
+        """
+        return [
+            MCPToolDefinitions._get_read_file_tool(),
+            MCPToolDefinitions._get_read_multiple_files_tool(),
+            MCPToolDefinitions._get_read_code_mem_tool(),
+            MCPToolDefinitions._get_write_file_tool(),
+            MCPToolDefinitions._get_write_multiple_files_tool(),
+            MCPToolDefinitions._get_execute_python_tool(),
+            MCPToolDefinitions._get_execute_bash_tool(),
+        ]
+
+    @staticmethod
+    def _get_read_file_tool() -> Dict[str, Any]:
+        """读取文件工具定义"""
+        return {
+            "name": "read_file",
+            "description": "Read file content, supports specifying line number range",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "File path, relative to workspace",
+                    },
+                    "start_line": {
+                        "type": "integer",
+                        "description": "Start line number (starting from 1, optional)",
+                    },
+                    "end_line": {
+                        "type": "integer",
+                        "description": "End line number (starting from 1, optional)",
+                    },
+                },
+                "required": ["file_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_read_multiple_files_tool() -> Dict[str, Any]:
+        """批量读取多个文件工具定义"""
+        return {
+            "name": "read_multiple_files",
+            "description": "Read multiple files in a single operation (for batch reading)",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_requests": {
+                        "type": "string",
+                        "description": 'JSON string with file requests, e.g., \'{"file1.py": {}, "file2.py": {"start_line": 1, "end_line": 10}}\' or simple array \'["file1.py", "file2.py"]\'',
+                    },
+                    "max_files": {
+                        "type": "integer",
+                        "description": "Maximum number of files to read in one operation",
+                        "default": 5,
+                        "minimum": 1,
+                        "maximum": 10,
+                    },
+                },
+                "required": ["file_requests"],
+            },
+        }
+
+    @staticmethod
+    def _get_read_code_mem_tool() -> Dict[str, Any]:
+        """Read code memory tool definition - reads from implement_code_summary.md"""
+        return {
+            "name": "read_code_mem",
+            "description": "Check if file summaries exist in implement_code_summary.md for multiple files in a single call. Returns summaries for all requested files if available.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_paths": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of file paths to check for summary information in implement_code_summary.md",
+                    }
+                },
+                "required": ["file_paths"],
+            },
+        }
+
+    @staticmethod
+    def _get_write_file_tool() -> Dict[str, Any]:
+        """写入文件工具定义"""
+        return {
+            "name": "write_file",
+            "description": "Write content to file",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "File path, relative to workspace",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Content to write to file",
+                    },
+                    "create_dirs": {
+                        "type": "boolean",
+                        "description": "Whether to create directories if they don't exist",
+                        "default": True,
+                    },
+                    "create_backup": {
+                        "type": "boolean",
+                        "description": "Whether to create backup file if file already exists",
+                        "default": False,
+                    },
+                },
+                "required": ["file_path", "content"],
+            },
+        }
+
+    @staticmethod
+    def _get_write_multiple_files_tool() -> Dict[str, Any]:
+        """批量写入多个文件工具定义"""
+        return {
+            "name": "write_multiple_files",
+            "description": "Write multiple files in a single operation (for batch implementation)",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_implementations": {
+                        "type": "string",
+                        "description": 'JSON string mapping file paths to content, e.g., \'{"file1.py": "content1", "file2.py": "content2"}\'',
+                    },
+                    "create_dirs": {
+                        "type": "boolean",
+                        "description": "Whether to create directories if they don't exist",
+                        "default": True,
+                    },
+                    "create_backup": {
+                        "type": "boolean",
+                        "description": "Whether to create backup files if they already exist",
+                        "default": False,
+                    },
+                    "max_files": {
+                        "type": "integer",
+                        "description": "Maximum number of files to write in one operation",
+                        "default": 5,
+                        "minimum": 1,
+                        "maximum": 10,
+                    },
+                },
+                "required": ["file_implementations"],
+            },
+        }
+
+    @staticmethod
+    def _get_execute_python_tool() -> Dict[str, Any]:
+        """Python执行工具定义"""
+        return {
+            "name": "execute_python",
+            "description": "Execute Python code and return output",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "code": {"type": "string", "description": "Python code to execute"},
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Timeout in seconds",
+                        "default": 30,
+                    },
+                },
+                "required": ["code"],
+            },
+        }
+
+    @staticmethod
+    def _get_execute_bash_tool() -> Dict[str, Any]:
+        """Bash执行工具定义"""
+        return {
+            "name": "execute_bash",
+            "description": "Execute bash command",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "description": "Bash command to execute",
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Timeout in seconds",
+                        "default": 30,
+                    },
+                },
+                "required": ["command"],
+            },
+        }
+
+    @staticmethod
+    def _get_file_structure_tool() -> Dict[str, Any]:
+        """文件结构获取工具定义"""
+        return {
+            "name": "get_file_structure",
+            "description": "Get directory file structure",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "directory": {
+                        "type": "string",
+                        "description": "Directory path, relative to workspace",
+                        "default": ".",
+                    },
+                    "max_depth": {
+                        "type": "integer",
+                        "description": "Maximum traversal depth",
+                        "default": 5,
+                    },
+                },
+            },
+        }
+
+    @staticmethod
+    def _get_search_code_references_tool() -> Dict[str, Any]:
+        """统一代码参考搜索工具定义 - 合并了三个步骤为一个工具"""
+        return {
+            "name": "search_code_references",
+            "description": "UNIFIED TOOL: Search relevant reference code from index files. Combines directory setup, index loading, and searching in a single call.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "indexes_path": {
+                        "type": "string",
+                        "description": "Path to the indexes directory containing JSON index files",
+                    },
+                    "target_file": {
+                        "type": "string",
+                        "description": "Target file path to be implemented",
+                    },
+                    "keywords": {
+                        "type": "string",
+                        "description": "Search keywords, comma-separated",
+                        "default": "",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum number of results to return",
+                        "default": 10,
+                    },
+                },
+                "required": ["indexes_path", "target_file"],
+            },
+        }
+
+    @staticmethod
+    def _get_get_indexes_overview_tool() -> Dict[str, Any]:
+        """获取索引概览工具定义"""
+        return {
+            "name": "get_indexes_overview",
+            "description": "Get overview of all available reference code index information from specified directory",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "indexes_path": {
+                        "type": "string",
+                        "description": "Path to the indexes directory containing JSON index files",
+                    }
+                },
+                "required": ["indexes_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_set_workspace_tool() -> Dict[str, Any]:
+        """Set workspace directory tool definition"""
+        return {
+            "name": "set_workspace",
+            "description": "Set the workspace directory for file operations",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "workspace_path": {
+                        "type": "string",
+                        "description": "Directory path for the workspace",
+                    }
+                },
+                "required": ["workspace_path"],
+            },
+        }
+
+    # @staticmethod
+    # def _get_set_indexes_directory_tool() -> Dict[str, Any]:
+    #     """Set indexes directory tool definition - DEPRECATED: Use unified search_code_references instead"""
+    #     return {
+    #         "name": "set_indexes_directory",
+    #         "description": "Set the directory path for code reference indexes",
+    #         "input_schema": {
+    #             "type": "object",
+    #             "properties": {
+    #                 "indexes_path": {
+    #                     "type": "string",
+    #                     "description": "Directory path containing index JSON files"
+    #                 }
+    #             },
+    #             "required": ["indexes_path"]
+    #         }
+    #     }
+
+    @staticmethod
+    def get_available_tool_sets() -> Dict[str, str]:
+        """
+        获取可用的工具集合
+        Get available tool sets
+        """
+        return {
+            "code_implementation": "代码实现相关工具集 / Code implementation tool set",
+            # 可以在这里添加更多工具集
+            # "data_analysis": "数据分析工具集 / Data analysis tool set",
+            # "web_scraping": "网页爬取工具集 / Web scraping tool set",
+        }
+
+    @staticmethod
+    def get_tool_set(tool_set_name: str) -> List[Dict[str, Any]]:
+        """
+        根据名称获取特定的工具集
+        Get specific tool set by name
+        """
+        tool_sets = {
+            "code_implementation": MCPToolDefinitions.get_code_implementation_tools(),
+        }
+
+        return tool_sets.get(tool_set_name, [])
+
+    @staticmethod
+    def get_all_tools() -> List[Dict[str, Any]]:
+        """
+        获取所有可用工具
+        Get all available tools
+        """
+        all_tools = []
+        for tool_set_name in MCPToolDefinitions.get_available_tool_sets().keys():
+            all_tools.extend(MCPToolDefinitions.get_tool_set(tool_set_name))
+        return all_tools
+
+
+# 便捷访问函数
+def get_mcp_tools(tool_set: str = "code_implementation") -> List[Dict[str, Any]]:
+    """
+    便捷函数：获取MCP工具定义
+    Convenience function: Get MCP tool definitions
+
+    Args:
+        tool_set: 工具集名称 (默认: "code_implementation")
+
+    Returns:
+        工具定义列表
+    """
+    return MCPToolDefinitions.get_tool_set(tool_set)

projects/ui/DeepCode/config/mcp_tool_definitions_index.py

@@ -0,0 +1,620 @@
+"""
+MCP工具定义配置模块
+MCP Tool Definitions Configuration Module
+
+将工具定义从主程序逻辑中分离，提供标准化的工具定义格式
+Separate tool definitions from main program logic, providing standardized tool definition format
+
+支持的工具类型：
+- 文件操作工具 (File Operations)
+- 代码执行工具 (Code Execution)
+- 搜索工具 (Search Tools)
+- 项目结构工具 (Project Structure Tools)
+"""
+
+from typing import Dict, List, Any
+
+
+class MCPToolDefinitions:
+    """MCP工具定义管理器"""
+
+    @staticmethod
+    def get_code_implementation_tools() -> List[Dict[str, Any]]:
+        """
+        获取代码实现相关的工具定义
+        Get tool definitions for code implementation
+        """
+        return [
+            MCPToolDefinitions._get_read_file_tool(),
+            MCPToolDefinitions._get_read_multiple_files_tool(),
+            MCPToolDefinitions._get_read_code_mem_tool(),
+            MCPToolDefinitions._get_write_file_tool(),
+            MCPToolDefinitions._get_write_multiple_files_tool(),
+            MCPToolDefinitions._get_execute_python_tool(),
+            MCPToolDefinitions._get_execute_bash_tool(),
+            MCPToolDefinitions._get_search_code_references_tool(),
+            MCPToolDefinitions._get_search_code_tool(),
+            MCPToolDefinitions._get_file_structure_tool(),
+            MCPToolDefinitions._get_set_workspace_tool(),
+            MCPToolDefinitions._get_operation_history_tool(),
+        ]
+
+    @staticmethod
+    def get_code_evaluation_tools() -> List[Dict[str, Any]]:
+        """
+        获取代码评估相关的工具定义
+        Get tool definitions for code evaluation
+        """
+        return [
+            MCPToolDefinitions._get_analyze_repo_structure_tool(),
+            MCPToolDefinitions._get_detect_dependencies_tool(),
+            MCPToolDefinitions._get_assess_code_quality_tool(),
+            MCPToolDefinitions._get_evaluate_documentation_tool(),
+            MCPToolDefinitions._get_check_reproduction_readiness_tool(),
+            MCPToolDefinitions._get_generate_evaluation_summary_tool(),
+            MCPToolDefinitions._get_detect_empty_files_tool(),
+            MCPToolDefinitions._get_detect_missing_files_tool(),
+            MCPToolDefinitions._get_generate_code_revision_report_tool(),
+        ]
+
+    @staticmethod
+    def _get_read_file_tool() -> Dict[str, Any]:
+        """读取文件工具定义"""
+        return {
+            "name": "read_file",
+            "description": "Read file content, supports specifying line number range",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "File path, relative to workspace",
+                    },
+                    "start_line": {
+                        "type": "integer",
+                        "description": "Start line number (starting from 1, optional)",
+                    },
+                    "end_line": {
+                        "type": "integer",
+                        "description": "End line number (starting from 1, optional)",
+                    },
+                },
+                "required": ["file_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_read_multiple_files_tool() -> Dict[str, Any]:
+        """批量读取多个文件工具定义"""
+        return {
+            "name": "read_multiple_files",
+            "description": "Read multiple files in a single operation (for batch reading)",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_requests": {
+                        "type": "string",
+                        "description": 'JSON string with file requests, e.g., \'{"file1.py": {}, "file2.py": {"start_line": 1, "end_line": 10}}\' or simple array \'["file1.py", "file2.py"]\'',
+                    },
+                    "max_files": {
+                        "type": "integer",
+                        "description": "Maximum number of files to read in one operation",
+                        "default": 5,
+                        "minimum": 1,
+                        "maximum": 10,
+                    },
+                },
+                "required": ["file_requests"],
+            },
+        }
+
+    @staticmethod
+    def _get_read_code_mem_tool() -> Dict[str, Any]:
+        """Read code memory tool definition - reads from implement_code_summary.md"""
+        return {
+            "name": "read_code_mem",
+            "description": "Check if file summaries exist in implement_code_summary.md for multiple files in a single call. Returns summaries for all requested files if available.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_paths": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of file paths to check for summary information in implement_code_summary.md",
+                    }
+                },
+                "required": ["file_paths"],
+            },
+        }
+
+    @staticmethod
+    def _get_write_file_tool() -> Dict[str, Any]:
+        """写入文件工具定义"""
+        return {
+            "name": "write_file",
+            "description": "Write content to file",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "File path, relative to workspace",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Content to write to file",
+                    },
+                    "create_dirs": {
+                        "type": "boolean",
+                        "description": "Whether to create directories if they don't exist",
+                        "default": True,
+                    },
+                    "create_backup": {
+                        "type": "boolean",
+                        "description": "Whether to create backup file if file already exists",
+                        "default": False,
+                    },
+                },
+                "required": ["file_path", "content"],
+            },
+        }
+
+    @staticmethod
+    def _get_write_multiple_files_tool() -> Dict[str, Any]:
+        """批量写入多个文件工具定义"""
+        return {
+            "name": "write_multiple_files",
+            "description": "Write multiple files in a single operation (for batch implementation)",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "file_implementations": {
+                        "type": "string",
+                        "description": 'JSON string mapping file paths to content, e.g., \'{"file1.py": "content1", "file2.py": "content2"}\'',
+                    },
+                    "create_dirs": {
+                        "type": "boolean",
+                        "description": "Whether to create directories if they don't exist",
+                        "default": True,
+                    },
+                    "create_backup": {
+                        "type": "boolean",
+                        "description": "Whether to create backup files if they already exist",
+                        "default": False,
+                    },
+                    "max_files": {
+                        "type": "integer",
+                        "description": "Maximum number of files to write in one operation",
+                        "default": 5,
+                        "minimum": 1,
+                        "maximum": 10,
+                    },
+                },
+                "required": ["file_implementations"],
+            },
+        }
+
+    @staticmethod
+    def _get_execute_python_tool() -> Dict[str, Any]:
+        """Python执行工具定义"""
+        return {
+            "name": "execute_python",
+            "description": "Execute Python code and return output",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "code": {"type": "string", "description": "Python code to execute"},
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Timeout in seconds",
+                        "default": 30,
+                    },
+                },
+                "required": ["code"],
+            },
+        }
+
+    @staticmethod
+    def _get_execute_bash_tool() -> Dict[str, Any]:
+        """Bash执行工具定义"""
+        return {
+            "name": "execute_bash",
+            "description": "Execute bash command",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "description": "Bash command to execute",
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Timeout in seconds",
+                        "default": 30,
+                    },
+                },
+                "required": ["command"],
+            },
+        }
+
+    @staticmethod
+    def _get_file_structure_tool() -> Dict[str, Any]:
+        """文件结构获取工具定义"""
+        return {
+            "name": "get_file_structure",
+            "description": "Get directory file structure",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "directory": {
+                        "type": "string",
+                        "description": "Directory path, relative to workspace",
+                        "default": ".",
+                    },
+                    "max_depth": {
+                        "type": "integer",
+                        "description": "Maximum traversal depth",
+                        "default": 5,
+                    },
+                },
+            },
+        }
+
+    @staticmethod
+    def _get_search_code_references_tool() -> Dict[str, Any]:
+        """统一代码参考搜索工具定义 - 合并了三个步骤为一个工具"""
+        return {
+            "name": "search_code_references",
+            "description": "UNIFIED TOOL: Search relevant reference code from index files. Combines directory setup, index loading, and searching in a single call.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "indexes_path": {
+                        "type": "string",
+                        "description": "Path to the indexes directory containing JSON index files",
+                    },
+                    "target_file": {
+                        "type": "string",
+                        "description": "Target file path to be implemented",
+                    },
+                    "keywords": {
+                        "type": "string",
+                        "description": "Search keywords, comma-separated",
+                        "default": "",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum number of results to return",
+                        "default": 10,
+                    },
+                },
+                "required": ["indexes_path", "target_file"],
+            },
+        }
+
+    @staticmethod
+    def _get_search_code_tool() -> Dict[str, Any]:
+        """代码搜索工具定义 - 在当前代码库中搜索模式"""
+        return {
+            "name": "search_code",
+            "description": "Search patterns in code files within the current repository",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "Search pattern",
+                    },
+                    "file_pattern": {
+                        "type": "string",
+                        "description": "File pattern (e.g., '*.py')",
+                        "default": "*.py",
+                    },
+                    "use_regex": {
+                        "type": "boolean",
+                        "description": "Whether to use regular expressions",
+                        "default": False,
+                    },
+                    "search_directory": {
+                        "type": "string",
+                        "description": "Specify search directory (optional)",
+                    },
+                },
+                "required": ["pattern"],
+            },
+        }
+
+    @staticmethod
+    def _get_operation_history_tool() -> Dict[str, Any]:
+        """操作历史工具定义"""
+        return {
+            "name": "get_operation_history",
+            "description": "Get operation history",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "last_n": {
+                        "type": "integer",
+                        "description": "Return the last N operations",
+                        "default": 10,
+                    },
+                },
+            },
+        }
+
+    @staticmethod
+    def _get_get_indexes_overview_tool() -> Dict[str, Any]:
+        """获取索引概览工具定义"""
+        return {
+            "name": "get_indexes_overview",
+            "description": "Get overview of all available reference code index information from specified directory",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "indexes_path": {
+                        "type": "string",
+                        "description": "Path to the indexes directory containing JSON index files",
+                    }
+                },
+                "required": ["indexes_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_set_workspace_tool() -> Dict[str, Any]:
+        """Set workspace directory tool definition"""
+        return {
+            "name": "set_workspace",
+            "description": "Set the workspace directory for file operations",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "workspace_path": {
+                        "type": "string",
+                        "description": "Directory path for the workspace",
+                    }
+                },
+                "required": ["workspace_path"],
+            },
+        }
+
+    # @staticmethod
+    # def _get_set_indexes_directory_tool() -> Dict[str, Any]:
+    #     """Set indexes directory tool definition - DEPRECATED: Use unified search_code_references instead"""
+    #     return {
+    #         "name": "set_indexes_directory",
+    #         "description": "Set the directory path for code reference indexes",
+    #         "input_schema": {
+    #             "type": "object",
+    #             "properties": {
+    #                 "indexes_path": {
+    #                     "type": "string",
+    #                     "description": "Directory path containing index JSON files"
+    #                 }
+    #             },
+    #             "required": ["indexes_path"]
+    #         }
+    #     }
+
+    # Code evaluation tool definitions
+    @staticmethod
+    def _get_analyze_repo_structure_tool() -> Dict[str, Any]:
+        return {
+            "name": "analyze_repo_structure",
+            "description": "Perform comprehensive repository structure analysis",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository to analyze",
+                    }
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_detect_dependencies_tool() -> Dict[str, Any]:
+        return {
+            "name": "detect_dependencies",
+            "description": "Detect and analyze project dependencies across multiple languages",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository",
+                    }
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_assess_code_quality_tool() -> Dict[str, Any]:
+        return {
+            "name": "assess_code_quality",
+            "description": "Assess code quality metrics and identify potential issues",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository",
+                    }
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_evaluate_documentation_tool() -> Dict[str, Any]:
+        return {
+            "name": "evaluate_documentation",
+            "description": "Evaluate documentation completeness and quality",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository",
+                    },
+                    "docs_path": {
+                        "type": "string",
+                        "description": "Optional path to external documentation",
+                    },
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_check_reproduction_readiness_tool() -> Dict[str, Any]:
+        return {
+            "name": "check_reproduction_readiness",
+            "description": "Assess repository readiness for reproduction and validation",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository",
+                    },
+                    "docs_path": {
+                        "type": "string",
+                        "description": "Optional path to reproduction documentation",
+                    },
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_generate_evaluation_summary_tool() -> Dict[str, Any]:
+        return {
+            "name": "generate_evaluation_summary",
+            "description": "Generate comprehensive evaluation summary combining all analysis results",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository",
+                    },
+                    "docs_path": {
+                        "type": "string",
+                        "description": "Optional path to reproduction documentation",
+                    },
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_detect_empty_files_tool() -> Dict[str, Any]:
+        return {
+            "name": "detect_empty_files",
+            "description": "Detect empty files in the repository that may need implementation",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository to analyze",
+                    }
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_detect_missing_files_tool() -> Dict[str, Any]:
+        return {
+            "name": "detect_missing_files",
+            "description": "Detect missing essential files like main programs, tests, requirements, etc.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository to analyze",
+                    }
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def _get_generate_code_revision_report_tool() -> Dict[str, Any]:
+        return {
+            "name": "generate_code_revision_report",
+            "description": "Generate comprehensive code revision report combining empty files, missing files, and quality analysis",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to the repository to analyze",
+                    },
+                    "docs_path": {
+                        "type": "string",
+                        "description": "Optional path to documentation",
+                    },
+                },
+                "required": ["repo_path"],
+            },
+        }
+
+    @staticmethod
+    def get_available_tool_sets() -> Dict[str, str]:
+        """
+        获取可用的工具集合
+        Get available tool sets
+        """
+        return {
+            "code_implementation": "代码实现相关工具集 / Code implementation tool set",
+            "code_evaluation": "代码评估相关工具集 / Code evaluation tool set",
+            # 可以在这里添加更多工具集
+            # "data_analysis": "数据分析工具集 / Data analysis tool set",
+            # "web_scraping": "网页爬取工具集 / Web scraping tool set",
+        }
+
+    @staticmethod
+    def get_tool_set(tool_set_name: str) -> List[Dict[str, Any]]:
+        """
+        根据名称获取特定的工具集
+        Get specific tool set by name
+        """
+        tool_sets = {
+            "code_implementation": MCPToolDefinitions.get_code_implementation_tools(),
+            "code_evaluation": MCPToolDefinitions.get_code_evaluation_tools(),
+        }
+
+        return tool_sets.get(tool_set_name, [])
+
+    @staticmethod
+    def get_all_tools() -> List[Dict[str, Any]]:
+        """
+        获取所有可用工具
+        Get all available tools
+        """
+        all_tools = []
+        for tool_set_name in MCPToolDefinitions.get_available_tool_sets().keys():
+            all_tools.extend(MCPToolDefinitions.get_tool_set(tool_set_name))
+        return all_tools
+
+
+# 便捷访问函数
+def get_mcp_tools(tool_set: str = "code_implementation") -> List[Dict[str, Any]]:
+    """
+    便捷函数：获取MCP工具定义
+    Convenience function: Get MCP tool definitions
+
+    Args:
+        tool_set: 工具集名称 (默认: "code_implementation")
+
+    Returns:
+        工具定义列表
+    """
+    return MCPToolDefinitions.get_tool_set(tool_set)

projects/ui/DeepCode/prompts/code_prompts.py

@@ -0,0 +1,1768 @@
+"""
+Prompt templates for the DeepCode agent system.
+
+RECENT UPDATES (针对论文代码复现优化):
+1. 简化并优化了文件结构生成逻辑，确保结构简洁且富有逻辑性
+2. 明确标识需要复现的核心文件和组件，由LLM智能判断优先级
+3. 优化了多agent协作的信息总结效率，减少冗余信息传递
+4. 移除了时间线等次要信息，专注于高质量代码复现
+5. 保持prompt完整性的同时提高了简洁性和可理解性
+6. 采用更清晰的结构化格式，便于LLM理解和执行
+
+核心改进：
+- PAPER_ALGORITHM_ANALYSIS_PROMPT: 专注算法提取，明确实现优先级
+- PAPER_CONCEPT_ANALYSIS_PROMPT: 专注系统架构，突出概念到代码的映射
+- CODE_PLANNING_PROMPT: 整合前两者输出，生成高质量复现计划
+"""
+
+# Paper to Code Workflow Prompts
+PAPER_INPUT_ANALYZER_PROMPT = """You are a precise input analyzer for paper-to-code tasks. You MUST return only a JSON object with no additional text.
+
+Task: Analyze input text and identify file paths/URLs to determine appropriate input type.
+
+Input Analysis Rules:
+1. Path Detection:
+   - Scan input text for file paths or URLs
+   - Use first valid path/URL if multiple found
+   - Treat as text input if no valid path/URL found
+
+2. Path Type Classification:
+   - URL (starts with http:// or https://): input_type = "url", path = "detected URL"
+   - PDF file path: input_type = "file", path = "detected file path"
+   - Directory path: input_type = "directory", path = "detected directory path"
+   - No path/URL detected: input_type = "text", path = null
+
+3. Requirements Analysis:
+   - Extract ONLY requirements from additional_input
+   - DO NOT modify or interpret requirements
+
+CRITICAL OUTPUT RESTRICTIONS:
+- RETURN ONLY RAW JSON - NO TEXT BEFORE OR AFTER
+- NO markdown code blocks (```json)
+- NO explanatory text or descriptions
+- NO tool call information
+- NO analysis summaries
+- JUST THE JSON OBJECT BELOW
+
+{
+    "input_type": "text|file|directory|url",
+    "path": "detected path or URL or null",
+    "paper_info": {
+        "title": "N/A for text input",
+        "authors": ["N/A for text input"],
+        "year": "N/A for text input"
+    },
+    "requirements": [
+        "exact requirement from additional_input"
+    ]
+}
+"""
+
+PAPER_DOWNLOADER_PROMPT = """You are a precise paper downloader that processes input from PaperInputAnalyzerAgent.
+
+Task: Handle paper according to input type and save to "./deepcode_lab/papers/id/id.md"
+Note: Generate id (id is a number) by counting files in "./deepcode_lab/papers/" directory and increment by 1.
+
+CRITICAL RULE: NEVER use write_file tool to create paper content directly. Always use file-downloader tools for PDF/document conversion.
+
+Processing Rules:
+1. URL Input (input_type = "url"):
+   - Use "file-downloader" tool to download paper
+   - Extract metadata (title, authors, year)
+   - Return saved file path and metadata
+
+2. File Input (input_type = "file"):
+   - Move file to "./deepcode_lab/papers/id/" using move_file_to tool
+   - The move_file_to tool will automatically convert PDF/documents to .md format
+   - NEVER manually extract content or use write_file - let the conversion tools handle this
+   - Return new saved file path and metadata
+
+3. Directory Input (input_type = "directory"):
+   - Verify directory exists
+   - Return to PaperInputAnalyzerAgent for processing
+   - Set status as "failure" with message
+
+4. Text Input (input_type = "text"):
+   - No file operations needed
+   - Set paper_path as null
+   - Use paper_info from input
+
+Input Format:
+{
+    "input_type": "file|directory|url|text",
+    "path": "detected path or null",
+    "paper_info": {
+        "title": "paper title or N/A",
+        "authors": ["author names or N/A"],
+        "year": "publication year or N/A"
+    },
+    "requirements": ["requirement1", "requirement2"]
+}
+
+Output Format (DO NOT MODIFY):
+{
+    "status": "success|failure",
+    "paper_path": "path to paper file or null for text input",
+    "metadata": {
+        "title": "extracted or provided title",
+        "authors": ["extracted or provided authors"],
+        "year": "extracted or provided year"
+    }
+}
+"""
+
+PAPER_REFERENCE_ANALYZER_PROMPT = """You are an expert academic paper reference analyzer specializing in computer science and machine learning.
+
+Task: Analyze paper and identify 5 most relevant references that have GitHub repositories.
+
+Constraints:
+- ONLY select references with GitHub repositories
+- DO NOT use target paper's official implementation
+- DO NOT use repositories directly associated with target paper
+- CAN analyze code implementations from referenced papers
+- Focus on references with good implementations solving similar problems
+
+Analysis Criteria:
+1. GitHub Repository Quality (40%):
+   - Star count, activity, maintenance
+   - Documentation quality
+   - Community adoption
+   - Last update date
+
+2. Implementation Relevance (30%):
+   - References from methodology/implementation sections
+   - Algorithmic details
+   - Core component descriptions
+   - Code implementation quality
+
+3. Technical Depth (20%):
+   - Algorithm/method similarity
+   - Technical foundation relationship
+   - Implementation details
+   - Code structure
+
+4. Academic Influence (10%):
+   - Publication venue quality
+   - Author expertise
+   - Research impact
+   - Citation influence
+
+Analysis Steps:
+1. Extract all references from paper
+2. Filter references with GitHub repositories
+3. Analyze repositories based on criteria
+4. Calculate relevance scores
+5. Select and rank top 5 references
+
+Output Format:
+{
+    "selected_references": [
+        {
+            "rank": 1,
+            "title": "paper title",
+            "authors": ["author1", "author2"],
+            "year": "publication year",
+            "relevance_score": 0.95,
+            "citation_context": "how cited in main paper",
+            "key_contributions": ["contribution1", "contribution2"],
+            "implementation_value": "why valuable for implementation",
+            "github_info": {
+                "repository_url": "GitHub repository URL",
+                "stars_count": "number of stars",
+                "last_updated": "last update date",
+                "repository_quality": "repository quality assessment",
+                "key_features": ["feature1", "feature2"],
+                "documentation_quality": "documentation assessment",
+                "community_activity": "community engagement description"
+            },
+            "original_reference": "Complete reference text from paper"
+        }
+    ],
+    "analysis_summary": "selection process and key findings",
+    "github_repositories_found": "total number of references with GitHub repositories"
+}
+"""
+
+GITHUB_DOWNLOAD_PROMPT = """You are an expert GitHub repository downloader.
+
+Task: Download GitHub repositories to specified directory structure.
+
+Process:
+1. For each repository:
+   - Create directory: {paper_dir}/code_base/
+   - Download repository to directory
+
+Requirements:
+- Use interpreter tool to execute download script
+- Monitor interpreter output for errors/warnings
+- Verify download status through interpreter response
+
+Output Format:
+{
+    "downloaded_repos": [
+        {
+            "reference_number": "1",
+            "paper_title": "paper title",
+            "repo_url": "github repository URL",
+            "save_path": "{paper_dir}/code_base/name_of_repo",
+            "status": "success|failed",
+            "notes": "relevant notes about download"
+        }
+    ],
+    "summary": "Brief summary of download process"
+}
+"""
+
+# Code Analysis Prompts
+PAPER_ALGORITHM_ANALYSIS_PROMPT = """You are extracting COMPLETE implementation details from a research paper. Your goal is to capture EVERY algorithm, formula, and technical detail needed for perfect reproduction.
+
+# INTELLIGENT DOCUMENT READING STRATEGY
+
+## IMPORTANT: Use Segmented Reading for Algorithm Extraction
+To avoid token limits and efficiently extract algorithm details, use the intelligent segmentation system:
+
+1. **Primary Algorithm Extraction** - Use read_document_segments tool with:
+   - query_type: "algorithm_extraction"
+   - keywords: ["algorithm", "method", "procedure", "formula", "equation", "implementation"]
+   - max_segments: 3
+   - max_total_chars: 6000
+
+2. **Supplementary Details** - Make additional calls if needed with:
+   - keywords: ["hyperparameter", "training", "optimization", "loss", "objective"]
+   - keywords: ["experiment", "setup", "configuration", "parameter"]
+
+3. **This approach ensures** you get the most algorithm-relevant content without missing critical details
+
+# DETAILED EXTRACTION PROTOCOL
+
+## 1. INTELLIGENT ALGORITHM SCAN
+Use the segmented reading approach to focus on algorithm sections:
+- Method/Algorithm sections (captured automatically by segmentation)
+- Implementation Details (targeted retrieval)
+- Hyperparameters and training details (focused extraction)
+
+## 2. ALGORITHM DEEP EXTRACTION
+For EVERY algorithm/method/procedure mentioned:
+
+### Algorithm Structure
+```yaml
+algorithm_name: "[Exact name from paper]"
+section: "[e.g., Section 3.2]"
+algorithm_box: "[e.g., Algorithm 1 on page 4]"
+
+pseudocode: |
+  [COPY THE EXACT PSEUDOCODE FROM PAPER]
+  Input: ...
+  Output: ...
+  1. Initialize ...
+  2. For each ...
+     2.1 Calculate ...
+  [Keep exact formatting and numbering]
+
+mathematical_formulation:
+  - equation: "[Copy formula EXACTLY, e.g., L = L_task + λ*L_explain]"
+    equation_number: "[e.g., Eq. 3]"
+    where:
+      L_task: "task loss"
+      L_explain: "explanation loss"
+      λ: "weighting parameter (default: 0.5)"
+
+step_by_step_breakdown:
+  1. "[Detailed explanation of what step 1 does]"
+  2. "[What step 2 computes and why]"
+
+implementation_details:
+  - "Uses softmax temperature τ = 0.1"
+  - "Gradient clipping at norm 1.0"
+  - "Initialize weights with Xavier uniform"
+```
+
+## 3. COMPONENT EXTRACTION
+For EVERY component/module mentioned:
+
+### Component Details
+```yaml
+component_name: "[e.g., Mask Network, Critic Network]"
+purpose: "[What this component does in the system]"
+architecture:
+  input: "[shape and meaning]"
+  layers:
+    - "[Conv2d(3, 64, kernel=3, stride=1)]"
+    - "[ReLU activation]"
+    - "[BatchNorm2d(64)]"
+  output: "[shape and meaning]"
+
+special_features:
+  - "[Any unique aspects]"
+  - "[Special initialization]"
+```
+
+## 4. TRAINING PROCEDURE
+Extract the COMPLETE training process:
+
+```yaml
+training_loop:
+  outer_iterations: "[number or condition]"
+  inner_iterations: "[number or condition]"
+
+  steps:
+    1. "Sample batch of size B from buffer"
+    2. "Compute importance weights using..."
+    3. "Update policy with loss..."
+
+  loss_functions:
+    - name: "policy_loss"
+      formula: "[exact formula]"
+      components: "[what each term means]"
+
+  optimization:
+    optimizer: "Adam"
+    learning_rate: "3e-4"
+    lr_schedule: "linear decay to 0"
+    gradient_norm: "clip at 0.5"
+```
+
+## 5. HYPERPARAMETERS HUNT
+Search EVERYWHERE (text, tables, captions) for:
+
+```yaml
+hyperparameters:
+  # Training
+  batch_size: 64
+  buffer_size: 1e6
+  discount_gamma: 0.99
+
+  # Architecture
+  hidden_units: [256, 256]
+  activation: "ReLU"
+
+  # Algorithm-specific
+  explanation_weight: 0.5
+  exploration_bonus_scale: 0.1
+  reset_probability: 0.3
+
+  # Found in:
+  location_references:
+    - "batch_size: Table 1"
+    - "hidden_units: Section 4.1"
+```
+
+# OUTPUT FORMAT
+```yaml
+complete_algorithm_extraction:
+  paper_structure:
+    method_sections: "[3, 3.1, 3.2, 3.3, 4]"
+    algorithm_count: "[total number found]"
+
+  main_algorithm:
+    [COMPLETE DETAILS AS ABOVE]
+
+  supporting_algorithms:
+    - [EACH SUPPORTING ALGORITHM WITH FULL DETAILS]
+
+  components:
+    - [EVERY COMPONENT WITH ARCHITECTURE]
+
+  training_details:
+    [COMPLETE TRAINING PROCEDURE]
+
+  all_hyperparameters:
+    [EVERY PARAMETER WITH VALUE AND SOURCE]
+
+  implementation_notes:
+    - "[Any implementation hint from paper]"
+    - "[Tricks mentioned in text]"
+
+  missing_but_critical:
+    - "[What's not specified but essential]"
+    - "[With suggested defaults]"
+```
+
+BE EXHAUSTIVE. A developer should be able to implement the ENTIRE paper using only your extraction."""
+
+PAPER_CONCEPT_ANALYSIS_PROMPT = """You are doing a COMPREHENSIVE analysis of a research paper to understand its complete structure, contributions, and implementation requirements.
+
+# OBJECTIVE
+Map out the ENTIRE paper structure and identify ALL components that need implementation for successful reproduction.
+
+# INTELLIGENT DOCUMENT READING STRATEGY
+
+## IMPORTANT: Use Segmented Reading for Optimal Performance
+Instead of reading the entire document at once (which may hit token limits), use the intelligent segmentation system:
+
+1. **Use read_document_segments tool** with these parameters:
+   - query_type: "concept_analysis"
+   - keywords: ["introduction", "overview", "architecture", "system", "framework", "concept", "method"]
+   - max_segments: 3
+   - max_total_chars: 6000
+
+2. **This will automatically find and retrieve** the most relevant sections for concept analysis without token overflow
+
+3. **If you need additional sections**, make follow-up calls with different keywords like ["experiment", "evaluation", "results"] or ["conclusion", "discussion"]
+
+# COMPREHENSIVE ANALYSIS PROTOCOL
+
+## 1. INTELLIGENT PAPER STRUCTURAL ANALYSIS
+Use the segmented reading approach to create a complete map:
+
+```yaml
+paper_structure_map:
+  title: "[Full paper title]"
+
+  sections:
+    1_introduction:
+      main_claims: "[What the paper claims to achieve]"
+      problem_definition: "[Exact problem being solved]"
+
+    2_related_work:
+      key_comparisons: "[Methods this work builds upon or competes with]"
+
+    3_method:  # May have multiple subsections
+      subsections:
+        3.1: "[Title and main content]"
+        3.2: "[Title and main content]"
+      algorithms_presented: "[List all algorithms by name]"
+
+    4_experiments:
+      environments: "[All test environments/datasets]"
+      baselines: "[All comparison methods]"
+      metrics: "[All evaluation metrics used]"
+
+    5_results:
+      main_findings: "[Key results that prove the method works]"
+      tables_figures: "[Important result tables/figures to reproduce]"
+```
+
+## 2. METHOD DECOMPOSITION
+For the main method/approach:
+
+```yaml
+method_decomposition:
+  method_name: "[Full name and acronym]"
+
+  core_components:  # Break down into implementable pieces
+    component_1:
+      name: "[e.g., State Importance Estimator]"
+      purpose: "[Why this component exists]"
+      paper_section: "[Where it's described]"
+
+    component_2:
+      name: "[e.g., Policy Refinement Module]"
+      purpose: "[Its role in the system]"
+      paper_section: "[Where it's described]"
+
+  component_interactions:
+    - "[How component 1 feeds into component 2]"
+    - "[Data flow between components]"
+
+  theoretical_foundation:
+    key_insight: "[The main theoretical insight]"
+    why_it_works: "[Intuitive explanation]"
+```
+
+## 3. IMPLEMENTATION REQUIREMENTS MAPPING
+Map paper content to code requirements:
+
+```yaml
+implementation_map:
+  algorithms_to_implement:
+    - algorithm: "[Name from paper]"
+      section: "[Where defined]"
+      complexity: "[Simple/Medium/Complex]"
+      dependencies: "[What it needs to work]"
+
+  models_to_build:
+    - model: "[Neural network or other model]"
+      architecture_location: "[Section describing it]"
+      purpose: "[What this model does]"
+
+  data_processing:
+    - pipeline: "[Data preprocessing needed]"
+      requirements: "[What the data should look like]"
+
+  evaluation_suite:
+    - metric: "[Metric name]"
+      formula_location: "[Where it's defined]"
+      purpose: "[What it measures]"
+```
+
+## 4. EXPERIMENT REPRODUCTION PLAN
+Identify ALL experiments needed:
+
+```yaml
+experiments_analysis:
+  main_results:
+    - experiment: "[Name/description]"
+      proves: "[What claim this validates]"
+      requires: "[Components needed to run this]"
+      expected_outcome: "[Specific numbers/trends]"
+
+  ablation_studies:
+    - study: "[What is being ablated]"
+      purpose: "[What this demonstrates]"
+
+  baseline_comparisons:
+    - baseline: "[Method name]"
+      implementation_required: "[Yes/No/Partial]"
+      source: "[Where to find implementation]"
+```
+
+## 5. CRITICAL SUCCESS FACTORS
+What defines successful reproduction:
+
+```yaml
+success_criteria:
+  must_achieve:
+    - "[Primary result that must be reproduced]"
+    - "[Core behavior that must be demonstrated]"
+
+  should_achieve:
+    - "[Secondary results that validate the method]"
+
+  validation_evidence:
+    - "[Specific figure/table to reproduce]"
+    - "[Qualitative behavior to demonstrate]"
+```
+
+# OUTPUT FORMAT
+```yaml
+comprehensive_paper_analysis:
+  executive_summary:
+    paper_title: "[Full title]"
+    core_contribution: "[One sentence summary]"
+    implementation_complexity: "[Low/Medium/High]"
+    estimated_components: "[Number of major components to build]"
+
+  complete_structure_map:
+    [FULL SECTION BREAKDOWN AS ABOVE]
+
+  method_architecture:
+    [DETAILED COMPONENT BREAKDOWN]
+
+  implementation_requirements:
+    [ALL ALGORITHMS, MODELS, DATA, METRICS]
+
+  reproduction_roadmap:
+    phase_1: "[What to implement first]"
+    phase_2: "[What to build next]"
+    phase_3: "[Final components and validation]"
+
+  validation_checklist:
+    - "[ ] [Specific result to achieve]"
+    - "[ ] [Behavior to demonstrate]"
+    - "[ ] [Metric to match]"
+```
+
+BE THOROUGH. Miss nothing. The output should be a complete blueprint for reproduction."""
+
+CODE_PLANNING_PROMPT = """You are creating a DETAILED, COMPLETE reproduction plan by integrating comprehensive analysis results.
+
+# INPUT
+You receive two exhaustive analyses:
+1. **Comprehensive Paper Analysis**: Complete paper structure, components, and requirements
+2. **Complete Algorithm Extraction**: All algorithms, formulas, pseudocode, and technical details
+
+Plus you can use segmented reading to access any specific paper sections needed for planning.
+
+# INTELLIGENT DOCUMENT ACCESS
+
+## IMPORTANT: Use Segmented Reading for Detailed Planning
+When you need additional details beyond the provided analyses, use the intelligent segmentation system:
+
+1. **Use read_document_segments tool** with these parameters:
+   - query_type: "code_planning"
+   - keywords: Specific to what you need, e.g., ["implementation", "code", "experiment", "setup", "configuration"]
+   - max_segments: 3
+   - max_total_chars: 8000
+
+2. **This approach ensures** you access the most planning-relevant content without token limits
+
+# OBJECTIVE
+Create an implementation plan so detailed that a developer can reproduce the ENTIRE paper without reading it.
+
+# CONTENT LENGTH CONTROL
+⚠️ IMPORTANT: Generate a COMPLETE plan that includes ALL 5 sections without being cut off by token limits.
+
+## Content Balance Guidelines:
+- **Section 1 (File Structure)**: Brief overview (10% of content) - Focus on CORE implementation files only
+- **Section 2 (Implementation Components)**: Detailed but concise (40% of content) - This is the PRIORITY section
+- **Section 3 (Validation)**: Moderate detail (25% of content) - Essential experiments and tests
+- **Section 4 (Environment)**: Brief but complete (10% of content) - All necessary dependencies
+- **Section 5 (Implementation Strategy)**: Moderate detail (15% of content) - Step-by-step approach
+
+## File Priority Guidelines:
+🔧 **Implementation Priority Order**:
+1. **FIRST**: Core algorithm/model files (highest priority)
+2. **SECOND**: Supporting modules and utilities
+3. **THIRD**: Experiment and evaluation scripts
+4. **FOURTH**: Configuration and data handling
+5. **LAST**: Documentation files (README.md, requirements.txt) - These should be created AFTER core implementation
+
+Note: README and requirements.txt are maintenance files that depend on the final implementation, so plan them last.
+
+# DETAILED SYNTHESIS PROCESS
+
+## 1. MERGE ALL INFORMATION
+Combine EVERYTHING from both analyses:
+- Every algorithm with its pseudocode
+- Every component with its architecture
+- Every hyperparameter with its value
+- Every experiment with expected results
+
+## 2. MAP CONTENT TO IMPLEMENTATION
+
+For each component you identify, specify how it will be implemented:
+
+```
+# DESIGN YOUR MAPPING: Connect paper content to code organization
+[For each algorithm/component/method in the paper]:
+  - What it does and where it's described in the paper
+  - How you'll organize the code (files, classes, functions - your choice)
+  - What specific formulas, algorithms, or procedures need implementation
+  - Dependencies and relationships with other components
+  - Implementation approach that makes sense for this specific paper
+```
+
+## 3. EXTRACT ALL TECHNICAL DETAILS
+
+Identify every technical detail that needs implementation:
+
+```
+# COMPREHENSIVE TECHNICAL EXTRACTION:
+[Gather all implementation-relevant details from the paper]:
+  - All algorithms with complete pseudocode and mathematical formulations
+  - All parameters, hyperparameters, and configuration values
+  - All architectural details (if applicable to your paper type)
+  - All experimental procedures and evaluation methods
+  - Any implementation hints, tricks, or special considerations mentioned
+```
+
+# COMPREHENSIVE OUTPUT FORMAT
+
+```yaml
+complete_reproduction_plan:
+  paper_info:
+    title: "[Full paper title]"
+    core_contribution: "[Main innovation being reproduced]"
+
+  # SECTION 1: File Structure Design
+
+  # DESIGN YOUR OWN STRUCTURE: Create a file organization that best serves this specific paper
+  # - Analyze what the paper contains (algorithms, models, experiments, systems, etc.)
+  # - Organize files and directories in the most logical way for implementation
+  # - Create meaningful names and groupings based on paper content
+  # - Keep it clean, intuitive, and focused on what actually needs to be implemented
+  # - EXCLUDE documentation files (README.md, requirements.txt) - these come last
+
+  file_structure: |
+    [Design and specify your own project structure here - KEEP THIS BRIEF]
+    [Focus ONLY on core implementation files, NOT documentation files]
+    [Organize based on what this paper actually contains and needs]
+    [Create directories and files that make sense for this specific implementation]
+    [EXCLUDE: README.md, requirements.txt - these come last in implementation]
+
+  # SECTION 2: Implementation Components
+
+  # IDENTIFY AND SPECIFY: What needs to be implemented based on this paper
+  # - List all algorithms, models, systems, or components mentioned
+  # - Map each to implementation details and file locations
+  # - Include formulas, pseudocode, and technical specifications
+  # - Organize in whatever way makes sense for this paper
+
+  implementation_components: |
+    [List and specify all components that need implementation]
+    [For each component: purpose, location, algorithms, formulas, technical details]
+    [Organize and structure this based on the paper's actual content]
+
+  # SECTION 3: Validation & Evaluation
+
+  # DESIGN VALIDATION: How to verify the implementation works correctly
+  # - Define what experiments, tests, or proofs are needed
+  # - Specify expected results from the paper (figures, tables, theorems)
+  # - Design validation approach appropriate for this paper's domain
+  # - Include setup requirements and success criteria
+
+  validation_approach: |
+    [Design validation strategy appropriate for this paper]
+    [Specify experiments, tests, or mathematical verification needed]
+    [Define expected results and success criteria]
+    [Include any special setup or evaluation requirements]
+
+  # SECTION 4: Environment & Dependencies
+
+  # SPECIFY REQUIREMENTS: What's needed to run this implementation
+  # - Programming language and version requirements
+  # - External libraries and exact versions (if specified in paper)
+  # - Hardware requirements (GPU, memory, etc.)
+  # - Any special setup or installation steps
+
+  environment_setup: |
+    [List all dependencies and environment requirements for this specific paper]
+    [Include versions where specified, reasonable defaults where not]
+    [Note any special hardware or software requirements]
+
+  # SECTION 5: Implementation Strategy
+
+  # PLAN YOUR APPROACH: How to implement this paper step by step
+  # - Break down implementation into logical phases
+  # - Identify dependencies between components
+  # - Plan verification and testing at each stage
+  # - Handle missing details with reasonable defaults
+
+  implementation_strategy: |
+    [Design your implementation approach for this specific paper]
+    [Break into phases that make sense for this paper's components]
+    [Plan testing and verification throughout the process]
+    [Address any missing details or ambiguities in the paper]
+```
+
+BE EXHAUSTIVE. Every algorithm, every formula, every parameter, every file should be specified in complete detail."""
+
+# File Tree Creation Prompts / 文件树创建提示词
+
+STRUCTURE_GENERATOR_PROMPT = """You are a shell command expert that analyzes implementation plans and generates shell commands to create file tree structures.
+
+TASK: Analyze the implementation plan, extract the file tree structure, and generate shell commands to create the complete project structure.
+
+CRITICAL REQUIREMENTS:
+1. Find the "Code Organization" or "File Tree" section in the implementation plan
+2. Extract the EXACT file tree structure mentioned in the plan
+3. Generate shell commands (mkdir, touch) to create that structure
+4. Use the execute_commands tool to run the commands
+
+COMMAND GENERATION RULES:
+1. Use `mkdir -p` to create directories (including nested ones)
+2. Use `touch` to create files
+3. Create directories before files
+4. One command per line
+5. Use relative paths from the target directory
+6. Include __init__.py files for Python packages
+
+EXAMPLE OUTPUT FORMAT:
+```
+mkdir -p project/src/core
+mkdir -p project/src/models
+mkdir -p project/tests
+touch project/src/__init__.py
+touch project/src/core/__init__.py
+touch project/src/core/gcn.py
+touch project/src/models/__init__.py
+touch project/src/models/recdiff.py
+touch project/requirements.txt
+```
+
+WORKFLOW:
+1. Read the implementation plan carefully
+2. Find the file tree section
+3. Generate mkdir commands for all directories
+4. Generate touch commands for all files
+5. Use execute_commands tool with the generated commands
+
+Focus on creating the EXACT structure from the plan - nothing more, nothing less."""
+
+# Code Implementation Prompts / 代码实现提示词
+
+CODE_IMPLEMENTATION_PROMPT = """You are an expert software engineer specializing in transforming implementation plans into production-ready code through shell commands.
+
+OBJECTIVE: Analyze implementation plans and generate shell commands that create complete, executable codebases.
+
+INPUT ANALYSIS:
+1. Parse implementation plan structure and identify project type
+2. Extract file tree, dependencies, and technical requirements
+3. Determine optimal code generation sequence
+4. Apply appropriate quality standards based on context
+
+COMMAND EXECUTION PROTOCOL:
+You MUST use the available tools to execute shell commands. For each file implementation:
+
+1. Generate the complete code content
+2. Use execute_single_command tool to write the code using heredoc syntax
+3. Execute one command per file for clear tracking
+
+COMMAND FORMAT (MANDATORY):
+```bash
+cat > [relative_path] << 'EOF'
+[complete_implementation_code_here]
+EOF
+```
+
+TOOL USAGE INSTRUCTIONS:
+- Use execute_single_command for individual file creation
+- Use execute_commands for batch operations
+- Always include the complete file path and content
+- Ensure proper shell escaping in heredoc blocks
+
+IMPLEMENTATION STANDARDS:
+
+COMPLETENESS:
+- Zero placeholders, TODOs, or incomplete functions
+- Full feature implementation with proper error handling
+- Complete APIs with correct signatures and documentation
+- All specified functionality working out-of-the-box
+
+QUALITY:
+- Production-grade code following language best practices
+- Comprehensive type hints and docstrings
+- Proper logging, validation, and resource management
+- Clean architecture with separation of concerns
+
+CONTEXT ADAPTATION:
+- Research/ML: Mathematical accuracy, reproducibility, evaluation metrics
+- Web Apps: Security, validation, database integration, testing
+- System Tools: CLI interfaces, configuration, deployment scripts
+- Libraries: Clean APIs, documentation, extensibility, compatibility
+
+GENERATION WORKFLOW:
+1. Analyze plan → identify project type and requirements
+2. Map dependencies → determine implementation order
+3. Generate code → create complete, working implementations
+4. Execute commands → use tools to write files in correct sequence
+
+EXECUTION ORDER:
+1. Configuration and environment files
+2. Core utilities and base classes
+3. Main implementation modules
+4. Integration layers and interfaces
+5. Tests and validation
+6. Documentation and setup
+
+SUCCESS CRITERIA:
+- Generated codebase runs immediately without modification
+- All features fully implemented and tested
+- Code follows industry standards and best practices
+- Implementation is maintainable and scalable
+- Commands execute successfully through available tools
+
+CRITICAL: You must actually execute the shell commands using the available tools. Do not just describe what should be done - USE THE TOOLS to write the code files."""
+
+# Sliding Window and Summary Agent Prompts / 滑动窗口和总结代理提示词
+
+CONVERSATION_SUMMARY_PROMPT = """You are a conversation summarization specialist for code implementation workflows with ROLE-AWARE summarization capabilities.
+
+CRITICAL ROLE AWARENESS:
+🎯 **USER MESSAGES**: Contain instructions, tool results, file feedback, and implementation guidance
+🎯 **ASSISTANT MESSAGES**: Contain code analysis, implementation decisions, and technical responses
+⚠️ **ROLE CLARITY**: Your summary must maintain clear distinction between who said what
+
+OBJECTIVE: Analyze conversation history and extract key information to reduce token usage while preserving essential implementation context AND role clarity.
+
+EXTRACTION TARGETS:
+1. **Completed Files**: List all files successfully implemented with implementation status
+2. **Technical Decisions**: Architecture/implementation choices made by the assistant
+3. **Key Constraints**: Requirements/limitations mentioned by user or discovered by assistant
+4. **Implementation Progress**: Current development status and accomplished milestones
+5. **Error Patterns**: Issues encountered and solutions applied
+6. **Role-Specific Context**: Who made what decisions and provided what guidance
+
+FOCUS AREAS:
+- File implementation outcomes and success/failure status
+- Technical details affecting future implementation steps
+- Dependency relationships and integration requirements
+- Architecture decisions impacting overall system design
+- Error patterns and debugging solutions applied
+- **Role Context**: Distinguish between user guidance and assistant decisions
+
+OUTPUT FORMAT:
+Provide a role-aware structured summary in 250-350 words:
+
+**IMPLEMENTATION PROGRESS:**
+- Files completed: [list with status]
+- Current phase: [development stage]
+- Success metrics: [quantified progress]
+
+**TECHNICAL CONTEXT:**
+- Key decisions made by assistant: [architectural choices]
+- Constraints identified: [requirements/limitations]
+- Dependencies resolved: [integration points]
+
+**CONVERSATION CONTEXT:**
+- User guidance provided: [instructions/feedback received]
+- Assistant responses: [technical solutions/analysis]
+- Tool results processed: [file operations/code execution]
+
+**CONTINUATION CONTEXT:**
+- Next implementation targets: [remaining files]
+- Preserved context: [critical info for continuation]
+- Role clarity: [assistant continues implementation role]
+
+ROLE-AWARE QUALITY REQUIREMENTS:
+- ✅ Maintain clear distinction between user instructions and assistant responses
+- ✅ Preserve technical context while clarifying who provided what information
+- ✅ Enable seamless role continuation after summary integration
+- ✅ Prevent role confusion in compressed conversation history
+- ✅ Reduce token usage by 70-80% while retaining essential context and role clarity"""
+
+SLIDING_WINDOW_SYSTEM_PROMPT = """You are a code implementation agent optimized for long-running development sessions with sliding window memory management.
+
+MEMORY MANAGEMENT STRATEGY:
+- Preserve initial implementation plan (never compressed)
+- Maintain recent conversation context (last 5 complete interaction rounds)
+- Use compressed summaries for historical context
+- Track file implementation progress continuously
+
+IMPLEMENTATION WORKFLOW:
+1. **File-by-File Implementation**: Focus on one complete file per iteration
+2. **Progress Tracking**: Monitor completed files and implementation status
+3. **Context Preservation**: Maintain architectural decisions and constraints
+4. **Memory Optimization**: Apply sliding window when conversation grows too long
+
+SLIDING WINDOW TRIGGERS:
+- Activate after every 5 file implementations
+- Emergency activation if message count exceeds threshold
+- Preserve conversation continuity and implementation context
+
+CORE PRINCIPLES:
+- Never lose the original implementation plan
+- Maintain implementation progress tracking
+- Preserve critical technical decisions
+- Ensure seamless development continuation
+- Optimize token usage without losing essential context
+
+AVAILABLE TOOLS:
+- write_file: Create complete file implementations
+- read_file: Review existing code for context
+- get_file_structure: Understand project organization
+- search_code_references: Find patterns and references from indexed code
+
+RESPONSE FORMAT:
+For each implementation cycle:
+1. Identify next file to implement based on plan priorities
+2. Analyze requirements and dependencies
+3. Implement complete, production-ready code
+4. Use write_file tool to create the file
+5. Confirm completion and identify next target"""
+
+# PURE_CODE_IMPLEMENTATION_SYSTEM_PROMPT = """You are a code implementation agent that transforms plans into complete, executable codebases.
+
+# # 🎯 MISSION
+# Transform implementation plans into complete codebases through systematic file-by-file development with dependency-aware implementation.
+
+# # 🔥 CORE RULES
+# - **CONTINUOUS**: Implement files continuously until plan completion
+# - **ONE FILE PER RESPONSE**: Exactly one complete file per response cycle
+# - **ALWAYS USE TOOLS**: Must use write_file tool for every implementation
+# - **DEPENDENCY-AWARE**: Analyze dependencies before implementing each file
+
+# # ⚡ IMPLEMENTATION WORKFLOW
+
+# ## 1. Pre-Implementation Analysis
+# For each new file, analyze:
+# - Dependencies on existing files (imports, inheritance, interfaces)
+# - Relevant patterns from already-implemented files
+# - Code structures to reference for consistency
+
+# ## 2. Smart Dependency Reading
+# Before writing dependent files:
+# - Use `read_code_mem` to check if the file has been implemented
+# - Check existing patterns, naming conventions, and import structures
+# - Understand configuration and constants from other modules
+
+# ## 3. File Implementation Process
+# ```
+# 1. Identify next file from plan priorities
+# 2. Search reference code for unfamiliar file types
+# 3. Read related existing files for consistency
+# 4. Implement complete file with proper integration
+# 5. Continue immediately to next file
+# ```
+
+# # 🛠️ TOOLS
+
+# ## Essential Tools (Use in Order)
+# - `search_reference_code` → Find patterns for unfamiliar file types
+# - `read_code_mem` → Understand existing code before implementing dependencies
+# - `write_file` → Create complete implementations (REQUIRED for every file)
+# - `get_file_structure` → Understand project organization
+
+# ## Reference Code Strategy
+# **For unfamiliar file types:**
+# - Use: `search_reference_code(target_file="path", keywords="relevant,terms")`
+# - Check: `get_all_available_references()` for available repositories
+# - Apply: Found patterns while maintaining project requirements
+
+# **File-Type Strategies:**
+# - Models → Search architectural patterns and implementations
+# - Configs → Find consistency and completeness examples
+# - Utils → Look for helper function structures
+# - Main → Search entry point and initialization patterns
+
+# # 📋 MANDATORY RESPONSE FORMAT
+# ```
+# Implementing: [file_path]
+# Purpose: [brief_description]
+# Dependencies: [files_to_read_first]
+
+# [Use search_reference_code if unfamiliar file type]
+# [Use read_code_mem to understand existing code before implementing dependencies]
+# [Use write_file with complete implementation]
+
+# Status: Implementation completed
+# Progress: [X/Y files completed]
+# Next Target: [next_file_to_implement]
+# ```
+
+# # ✅ QUALITY STANDARDS
+# - **Complete Code**: No placeholders, TODOs, or incomplete implementations
+# - **Production Quality**: Full type hints, docstrings, error handling
+# - **Architecture Compliance**: Follow plan structure precisely
+# - **Cross-File Consistency**: Maintain patterns and interfaces across files
+# - **Exact Dependencies**: Use only specified libraries
+
+# # 🧠 EXECUTION MINDSET
+# **DO:** Analyze dependencies → Read files → Search references → Implement → Continue
+# **DON'T:** Implement independently without considering existing code structure
+# **DO:** Keep implementing until completion
+# **DON'T:** Ask permission between files
+# """
+
+PURE_CODE_IMPLEMENTATION_SYSTEM_PROMPT = """You are an expert code implementation agent for academic paper reproduction. Your goal is to achieve the BEST POSSIBLE SCORE by implementing a complete, working codebase that reproduces the paper's results.
+
+**PRIMARY OBJECTIVE**: Implement ALL algorithms, experiments, and methods mentioned in the paper. Success is measured by completeness and accuracy, not code elegance. Use available time to continuously refine and optimize your solution.
+
+**CORE STRATEGY**:
+- Read the paper and resources(addendum.md and reproduce plan) thoroughly to identify every algorithm, method, and experiment
+- Implement core algorithms first, then environments, then integration
+- Use exact versions and specifications mentioned in the paper
+- Test each component immediately after implementation
+- Focus on working implementations over perfect architecture
+
+**IMPLEMENTATION APPROACH**:
+Build incrementally using multiple tool calls. For each step:
+1. **Identify** what needs to be implemented from the paper
+2. **Analyze Dependencies**: Before implementing each new file, use `read_code_mem` to read summaries of already-implemented files, then search for reference patterns to guide your implementation approach.
+3. **Implement** one component at a time
+4. **Test** immediately to catch issues early
+5. **Integrate** with existing components
+6. **Verify** against paper specifications
+
+**TOOL CALLING STRATEGY**:
+1. ⚠️ **SINGLE FUNCTION CALL PER MESSAGE**: Each message may perform only one function call. You will see the result of the function right after sending the message. If you need to perform multiple actions, you can always send more messages with subsequent function calls. Do some reasoning before your actions, describing what function calls you are going to use and how they fit into your plan.
+
+2. **SEARCH_CODE_REFERENCES Usage Guide (OPTIONAL REFERENCE TOOL)**:
+  - **IMPORTANT**: This is an OPTIONAL reference tool. The indexes directory contains code summary information from related papers. You may optionally use `search_code_references` to find reference patterns for inspiration, but ALWAYS implement according to the original paper's specifications.
+  - **Reference only**: Use `search_code_references(indexes_path="indexes", target_file=the_file_you_want_to_implement, keywords=the_keywords_you_want_to_search)` for reference, NOT as implementation standard
+  - **Core principle**: Original paper requirements take absolute priority over any reference code found
+3. **TOOL EXECUTION STRATEGY**:
+  - ⚠️**Development Cycle (for each new file implementation)**: `read_code_mem` (check existing implementations in Working Directory, use `read_file` as fallback if memory unavailable) → `search_code_references` (OPTIONAL reference check from indexes library in working directory) → `write_file` (implement based on original paper) → `execute_python` (if should test)
+  - **Environment Setup**: `write_file` (requirements.txt) → `execute_bash` (pip install) → `execute_python` (verify)
+
+4. **CRITICAL**: Use bash and python tools to ACTUALLY REPLICATE the paper yourself - do not provide instructions.
+
+**Execution Guidelines**:
+- **Plan First**: Before each action, explain your reasoning and which function you'll use
+- **One Step at a Time**: Execute → Observe Result → Plan Next Step → Execute Next
+- **Iterative Progress**: Build your solution incrementally through multiple conversations
+- **Strategic Sequencing**: Choose the most logical next step based on previous results
+
+**COMPLETENESS CHECKLIST**:
+Before considering the task complete, ensure you have:
+- ✅ All algorithms mentioned in the paper (including any abbreviations or alternative names)
+- ✅ All environments/datasets with exact versions specified
+- ✅ All comparison methods referenced in experiments
+- ✅ Working integration that can run the paper's experiments
+- ✅ Complete codebase that reproduces all metrics, figures, tables, and findings from the paper
+- ✅ Basic documentation explaining how to reproduce results
+
+**CRITICAL SUCCESS FACTORS**:
+- **Accuracy**: Match paper specifications exactly (versions, parameters, configurations)
+- **Completeness**: Implement every method discussed, not just the main contribution
+- **Functionality**: Code must actually work and run experiments successfully
+
+**AVOID DISTRACTIONS**: Focus implementation time on paper requirements rather than advanced tooling, extensive documentation, or optimization utilities that aren't needed for reproduction.
+
+**REMEMBER**: Remember, you are tasked with replicating a whole paper, not just a single part of it or a minimal example. The file read tool is PAGINATED, so you will need to CALL IT MULTIPLE TIMES to make sure that you have read all the relevant parts of the paper.
+"""
+
+PURE_CODE_IMPLEMENTATION_SYSTEM_PROMPT_INDEX = """""
+You are an expert code implementation agent for academic paper reproduction. Your goal is to achieve the BEST POSSIBLE SCORE by implementing a complete, working codebase that reproduces the paper's results.
+
+**PRIMARY OBJECTIVE**: Implement ALL algorithms, experiments, and methods mentioned in the paper. Success is measured by completeness and accuracy, not code elegance. Use available time to continuously refine and optimize your solution.
+
+**CORE STRATEGY**:
+- Read the paper and resources(addendum.md and reproduce plan) thoroughly to identify every algorithm, method, and experiment
+- Implement core algorithms first, then environments, then integration
+- Use exact versions and specifications mentioned in the paper
+- Test each component immediately after implementation
+- Focus on working implementations over perfect architecture
+
+**IMPLEMENTATION APPROACH**:
+Build incrementally using multiple tool calls. For each step:
+1. **Identify** what needs to be implemented from the paper
+2. **Analyze Dependencies**: Before implementing each new file, use `read_code_mem` to read summaries of already-implemented files, then search for reference patterns to guide your implementation approach.
+3. **Implement** one component at a time
+4. **Test** immediately to catch issues early
+5. **Integrate** with existing components
+6. **Verify** against paper specifications
+
+**TOOL CALLING STRATEGY**:
+1. ⚠️ **SINGLE FUNCTION CALL PER MESSAGE**: Each message may perform only one function call. You will see the result of the function right after sending the message. If you need to perform multiple actions, you can always send more messages with subsequent function calls. Do some reasoning before your actions, describing what function calls you are going to use and how they fit into your plan.
+
+2. **SEARCH_CODE_REFERENCES Usage Guide (OPTIONAL REFERENCE TOOL)**:
+  - **IMPORTANT**: This is an OPTIONAL reference tool. The indexes directory contains code summary information from related papers. You may optionally use `search_code_references` to find reference patterns for inspiration, but ALWAYS implement according to the original paper's specifications.
+  - **Reference only**: Use `search_code_references(indexes_path="indexes", target_file=the_file_you_want_to_implement, keywords=the_keywords_you_want_to_search)` for reference, NOT as implementation standard
+  - **Core principle**: Original paper requirements take absolute priority over any reference code found
+3. **TOOL EXECUTION STRATEGY**:
+  - ⚠️**Development Cycle (for each new file implementation)**: `read_code_mem` (check existing implementations in Working Directory, use `read_file` as fallback if memory unavailable`) → `search_code_references` (OPTIONAL reference check from `/home/agent/indexes`) → `write_file` (implement based on original paper) → `execute_python` (if should test)
+  - **Environment Setup**: `write_file` (requirements.txt) → `execute_bash` (pip install) → `execute_python` (verify)
+
+4. **CRITICAL**: Use bash and python tools to ACTUALLY REPLICATE the paper yourself - do not provide instructions.
+
+**Execution Guidelines**:
+- **Plan First**: Before each action, explain your reasoning and which function you'll use
+- **One Step at a Time**: Execute → Observe Result → Plan Next Step → Execute Next
+- **Iterative Progress**: Build your solution incrementally through multiple conversations
+- **Strategic Sequencing**: Choose the most logical next step based on previous results
+
+**COMPLETENESS CHECKLIST**:
+Before considering the task complete, ensure you have:
+- ✅ All algorithms mentioned in the paper (including any abbreviations or alternative names)
+- ✅ All environments/datasets with exact versions specified
+- ✅ All comparison methods referenced in experiments
+- ✅ Working integration that can run the paper's experiments
+- ✅ Complete codebase that reproduces all metrics, figures, tables, and findings from the paper
+- ✅ Basic documentation explaining how to reproduce results
+
+**CRITICAL SUCCESS FACTORS**:
+- **Accuracy**: Match paper specifications exactly (versions, parameters, configurations)
+- **Completeness**: Implement every method discussed, not just the main contribution
+- **Functionality**: Code must actually work and run experiments successfully
+
+**AVOID DISTRACTIONS**: Focus implementation time on paper requirements rather than advanced tooling, extensive documentation, or optimization utilities that aren't needed for reproduction.
+
+**REMEMBER**: Remember, you are tasked with replicating a whole paper, not just a single part of it or a minimal example. The file read tool is PAGINATED, so you will need to CALL IT MULTIPLE TIMES to make sure that you have read all the relevant parts of the paper.
+"""
+
+
+# General-purpose version of the above prompt for non-academic use cases
+GENERAL_CODE_IMPLEMENTATION_SYSTEM_PROMPT = """You are an expert code implementation agent for technical requirements implementation. Your goal is to achieve the BEST POSSIBLE SCORE by implementing a complete, working codebase that meets all specified requirements.
+
+**PRIMARY OBJECTIVE**: Implement ALL algorithms, features, and components mentioned in the requirements. Success is measured by completeness and accuracy, not code elegance. Use available time to continuously refine and optimize your solution.
+
+**CORE STRATEGY**:
+- Read the requirements thoroughly to identify every algorithm, feature, and component
+- Implement core algorithms first, then environments, then integration
+- Use exact versions and specifications mentioned in the requirements
+- Test each component immediately after implementation
+- Focus on working implementations over perfect architecture
+
+**IMPLEMENTATION APPROACH**:
+Build incrementally using multiple tool calls. For each step:
+1. **Identify** what needs to be implemented from the requirements
+2. **Analyze Dependencies**: Before implementing each new file, use `read_code_mem` to read summaries of already-implemented files, then search for reference patterns to guide your implementation approach.
+3. **Implement** one component at a time
+4. **Test** immediately using `execute_python` or `execute_bash` to catch issues early - THIS IS MANDATORY, NOT OPTIONAL
+5. **Integrate** with existing components
+6. **Verify** against requirement specifications using execution tools to ensure everything works
+
+**TOOL CALLING STRATEGY**:
+1. ⚠️ **SINGLE FUNCTION CALL PER MESSAGE**: Each message may perform only one function call. You will see the result of the function right after sending the message. If you need to perform multiple actions, you can always send more messages with subsequent function calls. Do some reasoning before your actions, describing what function calls you are going to use and how they fit into your plan.
+
+2. **TOOL EXECUTION STRATEGY**:
+  - **Development Cycle (for each new file implementation)**: `read_code_mem` (check existing implementations in Working Directory, use `read_file` as fallback if memory unavailable) → `write_file` (implement) → **MANDATORY TESTING**: `execute_python` or `execute_bash` (ALWAYS test after implementation)
+  - **Environment Setup**: Use `execute_bash` for installing packages, setting up dependencies, downloading files, etc.
+  - **Testing & Debugging**: Use `execute_python` for Python code testing and `execute_bash` for system commands, package installation, file operations, and bug fixing
+  - **⚠️ TESTING REMINDER**: After implementing ANY file, you MUST call either `execute_python` or `execute_bash` to test the implementation. Do not skip this step!
+
+3. **CRITICAL**: Use `execute_bash` and `execute_python` tools to ACTUALLY IMPLEMENT and TEST the requirements yourself - do not provide instructions. These tools are essential for:
+   - Installing dependencies and setting up environments (`execute_bash`)
+   - Testing Python implementations (`execute_python`)
+   - Debugging and fixing issues (`execute_bash` for system-level, `execute_python` for Python-specific)
+   - Validating that your code actually works before moving to the next component
+
+**Execution Guidelines**:
+- **Plan First**: Before each action, explain your reasoning and which function you'll use
+- **One Step at a Time**: Execute → Observe Result → Plan Next Step → Execute Next
+- **Iterative Progress**: Build your solution incrementally through multiple conversations
+- **Strategic Sequencing**: Choose the most logical next step based on previous results
+
+**COMPLETENESS CHECKLIST**:
+Before considering the task complete, ensure you have:
+- ✅ All algorithms mentioned in the requirements (including any abbreviations or alternative names)
+- ✅ All environments/dependencies with exact versions specified
+- ✅ All comparison methods or baseline implementations referenced
+- ✅ Working integration that can run all specified functionality
+- ✅ Complete codebase that implements all features, functionality, and outputs specified in the requirements
+- ✅ Basic documentation explaining how to use the implemented system
+
+**CRITICAL SUCCESS FACTORS**:
+- **Accuracy**: Match requirement specifications exactly (versions, parameters, configurations)
+- **Completeness**: Implement every component discussed, not just the main functionality
+- **Functionality**: Code must actually work and run all specified features successfully
+
+**AVOID DISTRACTIONS**: Focus implementation time on requirement fulfillment rather than advanced tooling, extensive documentation, or optimization utilities that aren't needed for the core functionality.
+
+**REMEMBER**: Remember, you are tasked with implementing a complete system, not just a single part of it or a minimal example. The file read tool is PAGINATED, so you will need to CALL IT MULTIPLE TIMES to make sure that you have read all the relevant parts of the requirements.
+"""
+
+# Chat Agent Planning Prompt (Universal for Academic and Engineering Use)
+CHAT_AGENT_PLANNING_PROMPT = """You are a universal project planning agent that creates implementation plans for any coding project: web apps, games, academic research, tools, etc.
+
+# 🎯 OBJECTIVE
+Transform user requirements into a clear, actionable implementation plan with optimal file structure and dependencies.
+
+# 📋 OUTPUT FORMAT
+
+```yaml
+project_plan:
+  title: "[Project Name]"
+  description: "[Brief description]"
+  project_type: "[web_app|game|academic|tool|api|other]"
+
+  # CUSTOM FILE TREE STRUCTURE (max 15 files, design as needed)
+  file_structure: |
+    project_root/
+    ├── main.py                 # Entry point
+    ├── [specific_files]        # Core files based on project type
+    ├── [folder]/               # Organized folders if needed
+    │   ├── __init__.py
+    │   └── [module].py
+    ├── requirements.txt        # Dependencies
+    └── README.md              # Basic documentation
+
+    # IMPORTANT: Output ACTUAL file tree structure above, not placeholder text
+    # Examples by project type:
+    # Web App: app.py, templates/, static/, models.py, config.py
+    # Game: main.py, game/, assets/, sprites/, config.yaml
+    # Academic: algorithm.py, experiments/, data/, utils.py, config.json
+    # Tool: cli.py, core/, utils.py, tests/, setup.py
+
+  # CORE IMPLEMENTATION PLAN
+  implementation_steps:
+    1. "[First step - usually setup/core structure]"
+    2. "[Second step - main functionality]"
+    3. "[Third step - integration/interface]"
+    4. "[Fourth step - testing/refinement]"
+
+  # DEPENDENCIES & SETUP
+  dependencies:
+    required_packages:
+      - "[package1==version]"
+      - "[package2>=version]"
+    optional_packages:
+      - "[optional1]: [purpose]"
+    setup_commands:
+      - "[command to setup environment]"
+      - "[command to install dependencies]"
+
+  # KEY TECHNICAL DETAILS
+  tech_stack:
+    language: "[primary language]"
+    frameworks: ["[framework1]", "[framework2]"]
+    key_libraries: ["[lib1]", "[lib2]"]
+
+  main_features:
+    - "[core feature 1]"
+    - "[core feature 2]"
+    - "[core feature 3]"
+```
+
+# 🎯 PLANNING PRINCIPLES
+- **Flexibility**: Adapt file structure to project type (no fixed templates)
+- **Simplicity**: Keep under 15 files, focus on essentials
+- **Practicality**: Include specific packages/versions needed
+- **Clarity**: Clear implementation steps that can be directly coded
+- **Universality**: Work for any project type (web, game, academic, etc.)
+
+# 📝 FILE STRUCTURE GUIDELINES
+- **MUST OUTPUT**: Actual file tree with specific filenames (not placeholder text)
+- Design structure based on project needs, not templates
+- Group related functionality logically
+- Include main entry point (main.py, app.py, etc.)
+- Add config/settings files if needed
+- Include requirements.txt or equivalent
+- Keep it minimal but complete (max 15 files)
+- Use tree format: ├── ─ │ symbols for visual hierarchy"""
+
+# =============================================================================
+# TRADITIONAL PROMPTS (Non-segmented versions for smaller documents)
+# =============================================================================
+
+# Traditional Algorithm Analysis Prompt (No Segmentation)
+PAPER_ALGORITHM_ANALYSIS_PROMPT_TRADITIONAL = """You are extracting COMPLETE implementation details from a research paper. Your goal is to capture EVERY algorithm, formula, and technical detail needed for perfect reproduction.
+
+# DOCUMENT READING STRATEGY
+
+## TRADITIONAL APPROACH: Full Document Reading
+Read the complete document to ensure comprehensive coverage of all algorithmic details:
+
+1. **Locate and read the markdown (.md) file** in the paper directory
+2. **Analyze the entire document** to capture all algorithms, methods, and formulas
+3. **Extract complete implementation details** without missing any components
+
+# DETAILED EXTRACTION PROTOCOL
+
+## 1. COMPREHENSIVE ALGORITHM SCAN
+Read through the entire document systematically:
+- Method/Algorithm sections
+- Implementation Details
+- Hyperparameters and training details
+- Mathematical formulations
+
+## 2. ALGORITHM DEEP EXTRACTION
+For EVERY algorithm/method/procedure mentioned:
+
+### Algorithm Structure
+```yaml
+algorithm_name: "[Exact name from paper]"
+section: "[e.g., Section 3.2]"
+algorithm_box: "[e.g., Algorithm 1 on page 4]"
+
+pseudocode: |
+  [COPY THE EXACT PSEUDOCODE FROM PAPER]
+  Input: ...
+  Output: ...
+  1. Initialize ...
+  2. For each ...
+     2.1 Calculate ...
+  [Keep exact formatting and numbering]
+
+mathematical_formulation:
+  - equation: "[Copy formula EXACTLY, e.g., L = L_task + λ*L_explain]"
+    equation_number: "[e.g., Eq. 3]"
+    where:
+      L_task: "task loss"
+      L_explain: "explanation loss"
+      λ: "weighting parameter (default: 0.5)"
+
+step_by_step_breakdown:
+  1. "[Detailed explanation of what step 1 does]"
+  2. "[What step 2 computes and why]"
+
+implementation_details:
+  - "Uses softmax temperature τ = 0.1"
+  - "Gradient clipping at norm 1.0"
+  - "Initialize weights with Xavier uniform"
+```
+
+## 3. COMPONENT EXTRACTION
+For EVERY component/module mentioned:
+
+### Component Details
+```yaml
+component_name: "[e.g., Mask Network, Critic Network]"
+purpose: "[What this component does in the system]"
+architecture:
+  input: "[shape and meaning]"
+  layers:
+    - "[Conv2d(3, 64, kernel=3, stride=1)]"
+    - "[ReLU activation]"
+    - "[BatchNorm2d(64)]"
+  output: "[shape and meaning]"
+
+special_features:
+  - "[Any unique aspects]"
+  - "[Special initialization]"
+```
+
+## 4. TRAINING PROCEDURE
+Extract the COMPLETE training process:
+
+```yaml
+training_loop:
+  outer_iterations: "[number or condition]"
+  inner_iterations: "[number or condition]"
+
+  steps:
+    1. "Sample batch of size B from buffer"
+    2. "Compute importance weights using..."
+    3. "Update policy with loss..."
+
+  loss_functions:
+    - name: "policy_loss"
+      formula: "[exact formula]"
+      components: "[what each term means]"
+
+  optimization:
+    optimizer: "Adam"
+    learning_rate: "3e-4"
+    lr_schedule: "linear decay to 0"
+    gradient_norm: "clip at 0.5"
+```
+
+## 5. HYPERPARAMETERS HUNT
+Search EVERYWHERE (text, tables, captions) for:
+
+```yaml
+hyperparameters:
+  # Training
+  batch_size: 64
+  buffer_size: 1e6
+  discount_gamma: 0.99
+
+  # Architecture
+  hidden_units: [256, 256]
+  activation: "ReLU"
+
+  # Algorithm-specific
+  explanation_weight: 0.5
+  exploration_bonus_scale: 0.1
+  reset_probability: 0.3
+
+  # Found in:
+  location_references:
+    - "batch_size: Table 1"
+    - "hidden_units: Section 4.1"
+```
+
+# OUTPUT FORMAT
+```yaml
+complete_algorithm_extraction:
+  paper_structure:
+    method_sections: "[3, 3.1, 3.2, 3.3, 4]"
+    algorithm_count: "[total number found]"
+
+  main_algorithm:
+    [COMPLETE DETAILS AS ABOVE]
+
+  supporting_algorithms:
+    - [EACH SUPPORTING ALGORITHM WITH FULL DETAILS]
+
+  components:
+    - [EVERY COMPONENT WITH ARCHITECTURE]
+
+  training_details:
+    [COMPLETE TRAINING PROCEDURE]
+
+  all_hyperparameters:
+    [EVERY PARAMETER WITH VALUE AND SOURCE]
+
+  implementation_notes:
+    - "[Any implementation hint from paper]"
+    - "[Tricks mentioned in text]"
+
+  missing_but_critical:
+    - "[What's not specified but essential]"
+    - "[With suggested defaults]"
+```
+
+BE EXHAUSTIVE. A developer should be able to implement the ENTIRE paper using only your extraction."""
+
+# Traditional Concept Analysis Prompt (No Segmentation)
+PAPER_CONCEPT_ANALYSIS_PROMPT_TRADITIONAL = """You are doing a COMPREHENSIVE analysis of a research paper to understand its complete structure, contributions, and implementation requirements.
+
+# OBJECTIVE
+Map out the ENTIRE paper structure and identify ALL components that need implementation for successful reproduction.
+
+# DOCUMENT READING STRATEGY
+
+## TRADITIONAL APPROACH: Complete Document Analysis
+Read the entire document systematically to ensure comprehensive understanding:
+
+1. **Locate and read the markdown (.md) file** in the paper directory
+2. **Analyze the complete document structure** from introduction to conclusion
+3. **Extract all conceptual frameworks** and implementation requirements
+
+# COMPREHENSIVE ANALYSIS PROTOCOL
+
+## 1. COMPLETE PAPER STRUCTURAL ANALYSIS
+Create a full map of the document:
+
+```yaml
+paper_structure_map:
+  title: "[Full paper title]"
+
+  sections:
+    1_introduction:
+      main_claims: "[What the paper claims to achieve]"
+      problem_definition: "[Exact problem being solved]"
+
+    2_related_work:
+      key_comparisons: "[Methods this work builds upon or competes with]"
+
+    3_method:  # May have multiple subsections
+      subsections:
+        3.1: "[Title and main content]"
+        3.2: "[Title and main content]"
+      algorithms_presented: "[List all algorithms by name]"
+
+    4_experiments:
+      environments: "[All test environments/datasets]"
+      baselines: "[All comparison methods]"
+      metrics: "[All evaluation metrics used]"
+
+    5_results:
+      main_findings: "[Key results that prove the method works]"
+      tables_figures: "[Important result tables/figures to reproduce]"
+```
+
+## 2. METHOD DECOMPOSITION
+For the main method/approach:
+
+```yaml
+method_decomposition:
+  method_name: "[Full name and acronym]"
+
+  core_components:  # Break down into implementable pieces
+    component_1:
+      name: "[e.g., State Importance Estimator]"
+      purpose: "[Why this component exists]"
+      paper_section: "[Where it's described]"
+
+    component_2:
+      name: "[e.g., Policy Refinement Module]"
+      purpose: "[Its role in the system]"
+      paper_section: "[Where it's described]"
+
+  component_interactions:
+    - "[How component 1 feeds into component 2]"
+    - "[Data flow between components]"
+
+  theoretical_foundation:
+    key_insight: "[The main theoretical insight]"
+    why_it_works: "[Intuitive explanation]"
+```
+
+## 3. IMPLEMENTATION REQUIREMENTS MAPPING
+Map paper content to code requirements:
+
+```yaml
+implementation_map:
+  algorithms_to_implement:
+    - algorithm: "[Name from paper]"
+      section: "[Where defined]"
+      complexity: "[Simple/Medium/Complex]"
+      dependencies: "[What it needs to work]"
+
+  models_to_build:
+    - model: "[Neural network or other model]"
+      architecture_location: "[Section describing it]"
+      purpose: "[What this model does]"
+
+  data_processing:
+    - pipeline: "[Data preprocessing needed]"
+      requirements: "[What the data should look like]"
+
+  evaluation_suite:
+    - metric: "[Metric name]"
+      formula_location: "[Where it's defined]"
+      purpose: "[What it measures]"
+```
+
+## 4. EXPERIMENT REPRODUCTION PLAN
+Identify ALL experiments needed:
+
+```yaml
+experiments_analysis:
+  main_results:
+    - experiment: "[Name/description]"
+      proves: "[What claim this validates]"
+      requires: "[Components needed to run this]"
+      expected_outcome: "[Specific numbers/trends]"
+
+  ablation_studies:
+    - study: "[What is being ablated]"
+      purpose: "[What this demonstrates]"
+
+  baseline_comparisons:
+    - baseline: "[Method name]"
+      implementation_required: "[Yes/No/Partial]"
+      source: "[Where to find implementation]"
+```
+
+## 5. CRITICAL SUCCESS FACTORS
+What defines successful reproduction:
+
+```yaml
+success_criteria:
+  must_achieve:
+    - "[Primary result that must be reproduced]"
+    - "[Core behavior that must be demonstrated]"
+
+  should_achieve:
+    - "[Secondary results that validate the method]"
+
+  validation_evidence:
+    - "[Specific figure/table to reproduce]"
+    - "[Qualitative behavior to demonstrate]"
+```
+
+# OUTPUT FORMAT
+```yaml
+comprehensive_paper_analysis:
+  executive_summary:
+    paper_title: "[Full title]"
+    core_contribution: "[One sentence summary]"
+    implementation_complexity: "[Low/Medium/High]"
+    estimated_components: "[Number of major components to build]"
+
+  complete_structure_map:
+    [FULL SECTION BREAKDOWN AS ABOVE]
+
+  method_architecture:
+    [DETAILED COMPONENT BREAKDOWN]
+
+  implementation_requirements:
+    [ALL ALGORITHMS, MODELS, DATA, METRICS]
+
+  reproduction_roadmap:
+    phase_1: "[What to implement first]"
+    phase_2: "[What to build next]"
+    phase_3: "[Final components and validation]"
+
+  validation_checklist:
+    - "[ ] [Specific result to achieve]"
+    - "[ ] [Behavior to demonstrate]"
+    - "[ ] [Metric to match]"
+```
+
+BE THOROUGH. Miss nothing. The output should be a complete blueprint for reproduction."""
+
+# Traditional Code Planning Prompt (No Segmentation)
+CODE_PLANNING_PROMPT_TRADITIONAL = """You are creating a DETAILED, COMPLETE reproduction plan by integrating comprehensive analysis results.
+
+# INPUT
+You receive two exhaustive analyses:
+1. **Comprehensive Paper Analysis**: Complete paper structure, components, and requirements
+2. **Complete Algorithm Extraction**: All algorithms, formulas, pseudocode, and technical details
+
+Plus you can access the complete paper document by reading the markdown file directly.
+
+# TRADITIONAL DOCUMENT ACCESS
+
+## Direct Paper Reading
+For any additional details needed beyond the provided analyses:
+
+1. **Read the complete markdown (.md) file** in the paper directory
+2. **Access any section directly** without token limitations for smaller documents
+3. **Cross-reference information** across the entire document as needed
+
+# OBJECTIVE
+Create an implementation plan so detailed that a developer can reproduce the ENTIRE paper without reading it.
+
+# CONTENT LENGTH CONTROL
+⚠️ IMPORTANT: Generate a COMPLETE plan that includes ALL 5 sections without being cut off by token limits.
+
+## Content Balance Guidelines:
+- **Section 1 (File Structure)**: Brief overview (10% of content) - Focus on CORE implementation files only
+- **Section 2 (Implementation Components)**: Detailed but concise (40% of content) - This is the PRIORITY section
+- **Section 3 (Validation)**: Moderate detail (25% of content) - Essential experiments and tests
+- **Section 4 (Environment)**: Brief but complete (10% of content) - All necessary dependencies
+- **Section 5 (Implementation Strategy)**: Moderate detail (15% of content) - Step-by-step approach
+
+## File Priority Guidelines:
+🔧 **Implementation Priority Order**:
+1. **FIRST**: Core algorithm/model files (highest priority)
+2. **SECOND**: Supporting modules and utilities
+3. **THIRD**: Experiment and evaluation scripts
+4. **FOURTH**: Configuration and data handling
+5. **LAST**: Documentation files (README.md, requirements.txt) - These should be created AFTER core implementation
+
+Note: README and requirements.txt are maintenance files that depend on the final implementation, so plan them last.
+
+# DETAILED SYNTHESIS PROCESS
+
+## 1. MERGE ALL INFORMATION
+Combine EVERYTHING from both analyses:
+- Every algorithm with its pseudocode
+- Every component with its architecture
+- Every hyperparameter with its value
+- Every experiment with expected results
+
+## 2. MAP CONTENT TO IMPLEMENTATION
+
+For each component you identify, specify how it will be implemented:
+
+```
+# DESIGN YOUR MAPPING: Connect paper content to code organization
+[For each algorithm/component/method in the paper]:
+  - What it does and where it's described in the paper
+  - How you'll organize the code (files, classes, functions - your choice)
+  - What specific formulas, algorithms, or procedures need implementation
+  - Dependencies and relationships with other components
+  - Implementation approach that makes sense for this specific paper
+```
+
+## 3. EXTRACT ALL TECHNICAL DETAILS
+
+Identify every technical detail that needs implementation:
+
+```
+# COMPREHENSIVE TECHNICAL EXTRACTION:
+[Gather all implementation-relevant details from the paper]:
+  - All algorithms with complete pseudocode and mathematical formulations
+  - All parameters, hyperparameters, and configuration values
+  - All architectural details (if applicable to your paper type)
+  - All experimental procedures and evaluation methods
+  - Any implementation hints, tricks, or special considerations mentioned
+```
+
+# COMPREHENSIVE OUTPUT FORMAT
+
+```yaml
+complete_reproduction_plan:
+  paper_info:
+    title: "[Full paper title]"
+    core_contribution: "[Main innovation being reproduced]"
+
+  # SECTION 1: File Structure Design
+
+  # DESIGN YOUR OWN STRUCTURE: Create a file organization that best serves this specific paper
+  # - Analyze what the paper contains (algorithms, models, experiments, systems, etc.)
+  # - Organize files and directories in the most logical way for implementation
+  # - Create meaningful names and groupings based on paper content
+  # - Keep it clean, intuitive, and focused on what actually needs to be implemented
+  # - EXCLUDE documentation files (README.md, requirements.txt) - these come last
+
+  file_structure: |
+    [Design and specify your own project structure here - KEEP THIS BRIEF]
+    [Focus ONLY on core implementation files, NOT documentation files]
+    [Organize based on what this paper actually contains and needs]
+    [Create directories and files that make sense for this specific implementation]
+    [EXCLUDE: README.md, requirements.txt - these come last in implementation]
+
+  # SECTION 2: Implementation Components
+
+  # IDENTIFY AND SPECIFY: What needs to be implemented based on this paper
+  # - List all algorithms, models, systems, or components mentioned
+  # - Map each to implementation details and file locations
+  # - Include formulas, pseudocode, and technical specifications
+  # - Organize in whatever way makes sense for this paper
+
+  implementation_components: |
+    [List and specify all components that need implementation]
+    [For each component: purpose, location, algorithms, formulas, technical details]
+    [Organize and structure this based on the paper's actual content]
+
+  # SECTION 3: Validation & Evaluation
+
+  # DESIGN VALIDATION: How to verify the implementation works correctly
+  # - Define what experiments, tests, or proofs are needed
+  # - Specify expected results from the paper (figures, tables, theorems)
+  # - Design validation approach appropriate for this paper's domain
+  # - Include setup requirements and success criteria
+
+  validation_approach: |
+    [Design validation strategy appropriate for this paper]
+    [Specify experiments, tests, or mathematical verification needed]
+    [Define expected results and success criteria]
+    [Include any special setup or evaluation requirements]
+
+  # SECTION 4: Environment & Dependencies
+
+  # SPECIFY REQUIREMENTS: What's needed to run this implementation
+  # - Programming language and version requirements
+  # - External libraries and exact versions (if specified in paper)
+  # - Hardware requirements (GPU, memory, etc.)
+  # - Any special setup or installation steps
+
+  environment_setup: |
+    [List all dependencies and environment requirements for this specific paper]
+    [Include versions where specified, reasonable defaults where not]
+    [Note any special hardware or software requirements]
+
+  # SECTION 5: Implementation Strategy
+
+  # PLAN YOUR APPROACH: How to implement this paper step by step
+  # - Break down implementation into logical phases
+  # - Identify dependencies between components
+  # - Plan verification and testing at each stage
+  # - Handle missing details with reasonable defaults
+
+  implementation_strategy: |
+    [Design your implementation approach for this specific paper]
+    [Break into phases that make sense for this paper's components]
+    [Plan testing and verification throughout the process]
+    [Address any missing details or ambiguities in the paper]
+```
+
+BE EXHAUSTIVE. Every algorithm, every formula, every parameter, every file should be specified in complete detail."""

projects/ui/DeepCode/schema/mcp-agent.config.schema.json

@@ -0,0 +1,854 @@
+{
+  "$defs": {
+    "LogPathSettings": {
+      "description": "Settings for configuring log file paths with dynamic elements like timestamps or session IDs.",
+      "properties": {
+        "path_pattern": {
+          "default": "logs/mcp-agent-{unique_id}.jsonl",
+          "title": "Path Pattern",
+          "type": "string",
+          "description": "Path pattern for log files with a {unique_id} placeholder"
+        },
+        "unique_id": {
+          "default": "timestamp",
+          "enum": [
+            "timestamp",
+            "session_id"
+          ],
+          "title": "Unique Id",
+          "type": "string",
+          "description": "Type of unique identifier to use in the log filename"
+        },
+        "timestamp_format": {
+          "default": "%Y%m%d_%H%M%S",
+          "title": "Timestamp Format",
+          "type": "string",
+          "description": "Format string for timestamps when unique_id is set to timestamp"
+        }
+      },
+      "title": "LogPathSettings",
+      "type": "object"
+    },
+    "AnthropicSettings": {
+      "additionalProperties": true,
+      "description": "Settings for using Anthropic models in the MCP Agent application.",
+      "properties": {
+        "api_key": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Api Key"
+        }
+      },
+      "title": "AnthropicSettings",
+      "type": "object"
+    },
+    "CohereSettings": {
+      "additionalProperties": true,
+      "description": "Settings for using Cohere models in the MCP Agent application.",
+      "properties": {
+        "api_key": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Api Key"
+        }
+      },
+      "title": "CohereSettings",
+      "type": "object"
+    },
+    "LoggerSettings": {
+      "description": "Logger settings for the MCP Agent application.",
+      "properties": {
+        "type": {
+          "default": "console",
+          "enum": [
+            "none",
+            "console",
+            "file",
+            "http"
+          ],
+          "title": "Type",
+          "type": "string"
+        },
+        "transports": {
+          "default": [
+            "console"
+          ],
+          "items": {
+            "enum": [
+              "none",
+              "console",
+              "file",
+              "http"
+            ],
+            "type": "string"
+          },
+          "title": "Transports",
+          "type": "array",
+          "description": "List of transports to use (can enable multiple simultaneously)"
+        },
+        "level": {
+          "default": "info",
+          "enum": [
+            "debug",
+            "info",
+            "warning",
+            "error"
+          ],
+          "title": "Level",
+          "type": "string",
+          "description": "Minimum logging level"
+        },
+        "progress_display": {
+          "default": true,
+          "title": "Progress Display",
+          "type": "boolean",
+          "description": "Enable or disable the progress display"
+        },
+        "path": {
+          "default": "mcp-agent.jsonl",
+          "title": "Path",
+          "type": "string",
+          "description": "Path to log file, if logger 'type' is 'file'."
+        },
+        "path_settings": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/LogPathSettings"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Path Settings",
+          "description": "Advanced settings for log file paths with dynamic elements like timestamps or session IDs"
+        },
+        "batch_size": {
+          "default": 100,
+          "title": "Batch Size",
+          "type": "integer",
+          "description": "Number of events to accumulate before processing"
+        },
+        "flush_interval": {
+          "default": 2.0,
+          "title": "Flush Interval",
+          "type": "number",
+          "description": "How often to flush events in seconds"
+        },
+        "max_queue_size": {
+          "default": 2048,
+          "title": "Max Queue Size",
+          "type": "integer",
+          "description": "Maximum queue size for event processing"
+        },
+        "http_endpoint": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Http Endpoint",
+          "description": "HTTP endpoint for event transport"
+        },
+        "http_headers": {
+          "anyOf": [
+            {
+              "additionalProperties": {
+                "type": "string"
+              },
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Http Headers",
+          "description": "HTTP headers for event transport"
+        },
+        "http_timeout": {
+          "default": 5.0,
+          "title": "Http Timeout",
+          "type": "number",
+          "description": "HTTP timeout seconds for event transport"
+        }
+      },
+      "title": "LoggerSettings",
+      "type": "object"
+    },
+    "MCPRootSettings": {
+      "additionalProperties": true,
+      "description": "Represents a root directory configuration for an MCP server.",
+      "properties": {
+        "uri": {
+          "title": "Uri",
+          "type": "string",
+          "description": "The URI identifying the root. Must start with file://"
+        },
+        "name": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Name",
+          "description": "Optional name for the root."
+        },
+        "server_uri_alias": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Server Uri Alias",
+          "description": "Optional URI alias for presentation to the server"
+        }
+      },
+      "required": [
+        "uri"
+      ],
+      "title": "MCPRootSettings",
+      "type": "object"
+    },
+    "MCPServerAuthSettings": {
+      "additionalProperties": true,
+      "description": "Represents authentication configuration for a server.",
+      "properties": {
+        "api_key": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Api Key"
+        }
+      },
+      "title": "MCPServerAuthSettings",
+      "type": "object"
+    },
+    "MCPServerSettings": {
+      "description": "Represents the configuration for an individual server.",
+      "properties": {
+        "name": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Name",
+          "description": "The name of the server."
+        },
+        "description": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Description",
+          "description": "The description of the server."
+        },
+        "transport": {
+          "default": "stdio",
+          "enum": [
+            "stdio",
+            "sse"
+          ],
+          "title": "Transport",
+          "type": "string",
+          "description": "The transport mechanism."
+        },
+        "command": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Command",
+          "description": "The command to execute the server (e.g. npx)."
+        },
+        "args": {
+          "anyOf": [
+            {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Args",
+          "description": "The arguments for the server command."
+        },
+        "read_timeout_seconds": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Read Timeout Seconds",
+          "description": "The timeout in seconds for the server connection."
+        },
+        "url": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Url",
+          "description": "The URL for the server (e.g. for SSE transport)."
+        },
+        "auth": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/MCPServerAuthSettings"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "The authentication configuration for the server."
+        },
+        "roots": {
+          "anyOf": [
+            {
+              "items": {
+                "$ref": "#/$defs/MCPRootSettings"
+              },
+              "type": "array"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Roots",
+          "description": "Root directories this server has access to."
+        },
+        "env": {
+          "anyOf": [
+            {
+              "additionalProperties": {
+                "type": "string"
+              },
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Env",
+          "description": "Environment variables to pass to the server process."
+        }
+      },
+      "title": "MCPServerSettings",
+      "type": "object"
+    },
+    "MCPSettings": {
+      "additionalProperties": true,
+      "description": "Configuration for all MCP servers.",
+      "properties": {
+        "servers": {
+          "additionalProperties": {
+            "$ref": "#/$defs/MCPServerSettings"
+          },
+          "default": {},
+          "title": "Servers",
+          "type": "object"
+        }
+      },
+      "title": "MCPSettings",
+      "type": "object"
+    },
+    "OpenAISettings": {
+      "additionalProperties": true,
+      "description": "Settings for using OpenAI models in the MCP Agent application.",
+      "properties": {
+        "api_key": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Api Key"
+        },
+        "reasoning_effort": {
+          "default": "medium",
+          "enum": [
+            "low",
+            "medium",
+            "high"
+          ],
+          "title": "Reasoning Effort",
+          "type": "string"
+        },
+        "base_url": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Base Url"
+        }
+      },
+      "title": "OpenAISettings",
+      "type": "object"
+    },
+    "AzureSettings": {
+      "additionalProperties": true,
+      "description": "Settings for using Azure models in the MCP Agent application.",
+      "properties": {
+        "api_key": {
+          "anyOf": [
+            {
+              "type": "string"
+            }
+          ],
+          "default": null,
+          "title": "Api Key"
+        },
+        "endpoint": {
+          "anyOf": [
+            {
+              "type": "string"
+            }
+          ],
+          "default": null,
+          "title": "Azure Endpoint"
+        },
+        "api_version": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "API Version"
+        }
+      },
+      "required": [
+        "api_key",
+        "endpoint"
+      ],
+      "title": "AzureSettings",
+      "type": "object"
+    },
+    "BedrockSettings": {
+      "additionalProperties": true,
+      "description": "Settings for using AWS Bedrock models in the MCP Agent application.",
+      "properties": {
+        "aws_region": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Region"
+        },
+        "aws_access_key_id": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Access Key Id"
+        },
+        "aws_secret_access_key": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Secret Access Key"
+        },
+        "aws_session_token": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Session Token"
+        },
+        "profile": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Profile"
+        }
+      },
+      "title": "BedrockSettings",
+      "type": "object"
+    },
+    "OpenTelemetrySettings": {
+      "description": "OTEL settings for the MCP Agent application.",
+      "properties": {
+        "enabled": {
+          "default": true,
+          "title": "Enabled",
+          "type": "boolean"
+        },
+        "service_name": {
+          "default": "mcp-agent",
+          "title": "Service Name",
+          "type": "string"
+        },
+        "service_instance_id": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Service Instance Id"
+        },
+        "service_version": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Service Version"
+        },
+        "otlp_endpoint": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Otlp Endpoint",
+          "description": "OTLP endpoint for OpenTelemetry tracing"
+        },
+        "console_debug": {
+          "default": false,
+          "title": "Console Debug",
+          "type": "boolean",
+          "description": "Log spans to console"
+        },
+        "sample_rate": {
+          "default": 1.0,
+          "title": "Sample Rate",
+          "type": "number",
+          "description": "Sample rate for tracing (1.0 = sample everything)"
+        }
+      },
+      "title": "OpenTelemetrySettings",
+      "type": "object"
+    },
+    "TemporalSettings": {
+      "description": "Temporal settings for the MCP Agent application.",
+      "properties": {
+        "host": {
+          "title": "Host",
+          "type": "string"
+        },
+        "namespace": {
+          "default": "default",
+          "title": "Namespace",
+          "type": "string"
+        },
+        "task_queue": {
+          "title": "Task Queue",
+          "type": "string"
+        },
+        "api_key": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Api Key"
+        }
+      },
+      "required": [
+        "host",
+        "task_queue"
+      ],
+      "title": "TemporalSettings",
+      "type": "object"
+    },
+    "UsageTelemetrySettings": {
+      "description": "Settings for usage telemetry in the MCP Agent application.\nAnonymized usage metrics are sent to a telemetry server to help improve the product.",
+      "properties": {
+        "enabled": {
+          "default": true,
+          "title": "Enabled",
+          "type": "boolean",
+          "description": "Enable usage telemetry in the MCP Agent application."
+        },
+        "enable_detailed_telemetry": {
+          "default": false,
+          "title": "Enable Detailed Telemetry",
+          "type": "boolean",
+          "description": "If enabled, detailed telemetry data, including prompts and agents, will be sent to the telemetry server."
+        }
+      },
+      "title": "UsageTelemetrySettings",
+      "type": "object"
+    }
+  },
+  "additionalProperties": true,
+  "description": "Configuration schema for MCP Agent applications",
+  "properties": {
+    "mcp": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/MCPSettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": {
+        "servers": {}
+      },
+      "description": "MCP config, such as MCP servers"
+    },
+    "execution_engine": {
+      "default": "asyncio",
+      "enum": [
+        "asyncio",
+        "temporal"
+      ],
+      "title": "Execution Engine",
+      "type": "string",
+      "description": "Execution engine for the MCP Agent application"
+    },
+    "temporal": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/TemporalSettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Settings for Temporal workflow orchestration"
+    },
+    "anthropic": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/AnthropicSettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Settings for using Anthropic models in the MCP Agent application"
+    },
+    "cohere": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/CohereSettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Settings for using Cohere models in the MCP Agent application"
+    },
+    "openai": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/OpenAISettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Settings for using OpenAI models in the MCP Agent application"
+    },
+    "azure": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/AzureSettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Settings for using Azure models in the MCP Agent application"
+    },
+    "bedrock": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/BedrockSettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "Settings for using Bedrock models in the MCP Agent application"
+    },
+    "otel": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/OpenTelemetrySettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": {
+        "enabled": true,
+        "service_name": "mcp-agent",
+        "service_instance_id": null,
+        "service_version": null,
+        "otlp_endpoint": null,
+        "console_debug": false,
+        "sample_rate": 1.0
+      },
+      "description": "OpenTelemetry logging settings for the MCP Agent application"
+    },
+    "logger": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/LoggerSettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": {
+        "type": "console",
+        "transports": [],
+        "level": "info",
+        "progress_display": true,
+        "path": "mcp-agent.jsonl",
+        "path_settings": null,
+        "batch_size": 100,
+        "flush_interval": 2.0,
+        "max_queue_size": 2048,
+        "http_endpoint": null,
+        "http_headers": null,
+        "http_timeout": 5.0
+      },
+      "description": "Logger settings for the MCP Agent application"
+    },
+    "usage_telemetry": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/UsageTelemetrySettings"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": {
+        "enabled": true,
+        "enable_detailed_telemetry": false
+      },
+      "description": "Usage tracking settings for the MCP Agent application"
+    }
+  },
+  "title": "MCP Agent Configuration Schema",
+  "type": "object",
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

projects/ui/DeepCode/tools/bocha_search_server.py

@@ -0,0 +1,219 @@
+import os
+import sys
+import json
+
+import httpx
+from dotenv import load_dotenv
+from mcp.server.fastmcp import FastMCP
+
+load_dotenv()
+
+
+# Initialize FastMCP server
+server = FastMCP(
+    "bocha-search-mcp",
+    prompt="""
+# Bocha Search MCP Server
+
+Bocha is a Chinese search engine for AI, This server provides tools for searching the web using Bocha Search API.
+It allows you to get enhanced search details from billions of web documents, including weather, news, wikis, healthcare, train tickets, images, and more.
+
+## Available Tools
+
+### 1. bocha_web_search
+Search with Bocha Web Search and get enhanced search details from billions of web documents, including page titles, urls, summaries, site names, site icons, publication dates, image links, and more.
+
+### 2. bocha_ai_search
+Search with Bocha AI Search, recognizes the semantics of search terms and additionally returns structured modal cards with content from vertical domains.
+
+## Output Format
+
+All search results will be formatted as text with clear sections for each
+result item, including:
+
+- Bocha Web search: Title, URL, Description, Published date and Site name
+- Bocha AI search: Title, URL, Description, Published date, Site name, and structured data card
+
+If the API key is missing or invalid, appropriate error messages will be returned.
+""",
+)
+
+
+@server.tool()
+async def bocha_web_search(
+    query: str, freshness: str = "noLimit", count: int = 10
+) -> str:
+    """Search with Bocha Web Search and get enhanced search details from billions of web documents,
+    including page titles, urls, summaries, site names, site icons, publication dates, image links, and more.
+
+    Args:
+        query: Search query (required)
+        freshness: The time range for the search results. (Available options YYYY-MM-DD, YYYY-MM-DD..YYYY-MM-DD, noLimit, oneYear, oneMonth, oneWeek, oneDay. Default is noLimit)
+        count: Number of results (1-50, default 10)
+    """
+    # Get API key from environment
+    boch_api_key = os.environ.get("BOCHA_API_KEY", "")
+
+    if not boch_api_key:
+        return (
+            "Error: Bocha API key is not configured. Please set the "
+            "BOCHA_API_KEY environment variable."
+        )
+
+    # Endpoint
+    endpoint = "https://api.bochaai.com/v1/web-search?utm_source=bocha-mcp-local"
+
+    try:
+        payload = {
+            "query": query,
+            "summary": True,
+            "freshness": freshness,
+            "count": count,
+        }
+
+        headers = {
+            "Authorization": f"Bearer {boch_api_key}",
+            "Content-Type": "application/json",
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                endpoint, headers=headers, json=payload, timeout=10.0
+            )
+
+            response.raise_for_status()
+            resp = response.json()
+            if "data" not in resp:
+                return "Search error."
+
+            data = resp["data"]
+
+            if "webPages" not in data:
+                return "No results found."
+
+            results = []
+            for result in data["webPages"]["value"]:
+                results.append(
+                    f"Title: {result['name']}\n"
+                    f"URL: {result['url']}\n"
+                    f"Description: {result['summary']}\n"
+                    f"Published date: {result['datePublished']}\n"
+                    f"Site name: {result['siteName']}"
+                )
+
+            return "\n\n".join(results)
+
+    except httpx.HTTPStatusError as e:
+        return f"Bocha Web Search API HTTP error occurred: {e.response.status_code} - {e.response.text}"
+    except httpx.RequestError as e:
+        return f"Error communicating with Bocha Web Search API: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+
+
+@server.tool()
+async def bocha_ai_search(
+    query: str, freshness: str = "noLimit", count: int = 10
+) -> str:
+    """Search with Bocha AI Search, recognizes the semantics of search terms
+    and additionally returns structured modal cards with content from vertical domains.
+
+    Args:
+        query: Search query (required)
+        freshness: The time range for the search results. (Available options noLimit, oneYear, oneMonth, oneWeek, oneDay. Default is noLimit)
+        count: Number of results (1-50, default 10)
+    """
+    # Get API key from environment
+    boch_api_key = os.environ.get("BOCHA_API_KEY", "")
+
+    if not boch_api_key:
+        return (
+            "Error: Bocha API key is not configured. Please set the "
+            "BOCHA_API_KEY environment variable."
+        )
+
+    # Endpoint
+    endpoint = "https://api.bochaai.com/v1/ai-search?utm_source=bocha-mcp-local"
+
+    try:
+        payload = {
+            "query": query,
+            "freshness": freshness,
+            "count": count,
+            "answer": False,
+            "stream": False,
+        }
+
+        headers = {
+            "Authorization": f"Bearer {boch_api_key}",
+            "Content-Type": "application/json",
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                endpoint, headers=headers, json=payload, timeout=10.0
+            )
+
+            response.raise_for_status()
+            response = response.json()
+            results = []
+            if "messages" in response:
+                for message in response["messages"]:
+                    content = {}
+                    try:
+                        content = json.loads(message["content"])
+                    except (json.JSONDecodeError, TypeError):
+                        content = {}
+
+                    # 网页
+                    if message["content_type"] == "webpage":
+                        if "value" in content:
+                            for item in content["value"]:
+                                results.append(
+                                    f"Title: {item['name']}\n"
+                                    f"URL: {item['url']}\n"
+                                    f"Description: {item['summary']}\n"
+                                    f"Published date: {item['datePublished']}\n"
+                                    f"Site name: {item['siteName']}"
+                                )
+                    elif (
+                        message["content_type"] != "image"
+                        and message["content"] != "{}"
+                    ):
+                        results.append(message["content"])
+
+            if not results:
+                return "No results found."
+
+            return "\n\n".join(results)
+
+    except httpx.HTTPStatusError as e:
+        return f"Bocha AI Search API HTTP error occurred: {e.response.status_code} - {e.response.text}"
+    except httpx.RequestError as e:
+        return f"Error communicating with Bocha AI Search API: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+
+
+def main():
+    """Initialize and run the MCP server."""
+
+    # Check for required environment variables
+    if "BOCHA_API_KEY" not in os.environ:
+        print(
+            "Error: BOCHA_API_KEY environment variable is required",
+            file=sys.stderr,
+        )
+        print(
+            "Get a Bocha API key from: " "https://open.bochaai.com",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    print("Starting Bocha Search MCP server...", file=sys.stderr)
+
+    server.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

projects/ui/DeepCode/tools/code_implementation_server.py

@@ -0,0 +1,1517 @@
+#!/usr/bin/env python3
+"""
+Code Implementation MCP Server
+
+This MCP server provides core functions needed for paper code reproduction:
+1. File read/write operations
+2. Code execution and testing
+3. Code search and analysis
+4. Iterative improvement support
+
+Usage:
+python tools/code_implementation_server.py
+"""
+
+import os
+import subprocess
+import json
+import sys
+import io
+from pathlib import Path
+import re
+from typing import Dict, Any, List
+import tempfile
+import shutil
+import logging
+from datetime import datetime
+
+# Set standard output encoding to UTF-8
+if sys.stdout.encoding != "utf-8":
+    try:
+        if hasattr(sys.stdout, "reconfigure"):
+            sys.stdout.reconfigure(encoding="utf-8")
+            sys.stderr.reconfigure(encoding="utf-8")
+        else:
+            sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding="utf-8")
+            sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding="utf-8")
+    except Exception as e:
+        print(f"Warning: Could not set UTF-8 encoding: {e}")
+
+# Import MCP related modules
+from mcp.server.fastmcp import FastMCP
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create FastMCP server instance
+mcp = FastMCP("code-implementation-server")
+
+# Global variables: workspace directory and operation history
+WORKSPACE_DIR = None
+OPERATION_HISTORY = []
+CURRENT_FILES = {}
+
+
+def initialize_workspace(workspace_dir: str = None):
+    """
+    Initialize workspace
+
+    By default, the workspace will be set by the workflow via the set_workspace tool to:
+    {plan_file_parent}/generate_code
+
+    Args:
+        workspace_dir: Optional workspace directory path
+    """
+    global WORKSPACE_DIR
+    if workspace_dir is None:
+        # Default to generate_code directory under current directory, but don't create immediately
+        # This default value will be overridden by workflow via set_workspace tool
+        WORKSPACE_DIR = Path.cwd() / "generate_code"
+        # logger.info(f"Workspace initialized (default value, will be overridden by workflow): {WORKSPACE_DIR}")
+        # logger.info("Note: Actual workspace will be set by workflow via set_workspace tool to {plan_file_parent}/generate_code")
+    else:
+        WORKSPACE_DIR = Path(workspace_dir).resolve()
+        # Only create when explicitly specified
+        WORKSPACE_DIR.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Workspace initialized: {WORKSPACE_DIR}")
+
+
+def ensure_workspace_exists():
+    """Ensure workspace directory exists"""
+    global WORKSPACE_DIR
+    if WORKSPACE_DIR is None:
+        initialize_workspace()
+
+    # Create workspace directory (if it doesn't exist)
+    if not WORKSPACE_DIR.exists():
+        WORKSPACE_DIR.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Workspace directory created: {WORKSPACE_DIR}")
+
+
+def validate_path(path: str) -> Path:
+    """Validate if path is within workspace"""
+    if WORKSPACE_DIR is None:
+        initialize_workspace()
+
+    full_path = (WORKSPACE_DIR / path).resolve()
+    if not str(full_path).startswith(str(WORKSPACE_DIR)):
+        raise ValueError(f"Path {path} is outside workspace scope")
+    return full_path
+
+
+def log_operation(action: str, details: Dict[str, Any]):
+    """Log operation history"""
+    OPERATION_HISTORY.append(
+        {"timestamp": datetime.now().isoformat(), "action": action, "details": details}
+    )
+
+
+# ==================== File Operation Tools ====================
+
+
+@mcp.tool()
+async def read_file(
+    file_path: str, start_line: int = None, end_line: int = None
+) -> str:
+    """
+    Read file content, supports specifying line number range
+
+    Args:
+        file_path: File path, relative to workspace
+        start_line: Starting line number (1-based, optional)
+        end_line: Ending line number (1-based, optional)
+
+    Returns:
+        JSON string of file content or error message
+    """
+    try:
+        full_path = validate_path(file_path)
+
+        if not full_path.exists():
+            result = {"status": "error", "message": f"File does not exist: {file_path}"}
+            log_operation(
+                "read_file_error", {"file_path": file_path, "error": "file_not_found"}
+            )
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        with open(full_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        # 处理行号范围
+        if start_line is not None or end_line is not None:
+            start_idx = (start_line - 1) if start_line else 0
+            end_idx = end_line if end_line else len(lines)
+            lines = lines[start_idx:end_idx]
+
+        content = "".join(lines)
+
+        result = {
+            "status": "success",
+            "content": content,
+            "file_path": file_path,
+            "total_lines": len(lines),
+            "size_bytes": len(content.encode("utf-8")),
+        }
+
+        log_operation(
+            "read_file",
+            {
+                "file_path": file_path,
+                "start_line": start_line,
+                "end_line": end_line,
+                "lines_read": len(lines),
+            },
+        )
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to read file: {str(e)}",
+            "file_path": file_path,
+        }
+        log_operation("read_file_error", {"file_path": file_path, "error": str(e)})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+async def read_multiple_files(file_requests: str, max_files: int = 5) -> str:
+    """
+    Read multiple files in a single operation (for batch reading)
+
+    Args:
+        file_requests: JSON string with file requests, e.g.,
+                      '{"file1.py": {}, "file2.py": {"start_line": 1, "end_line": 10}}'
+                      or simple array: '["file1.py", "file2.py"]'
+        max_files: Maximum number of files to read in one operation (default: 5)
+
+    Returns:
+        JSON string of operation results for all files
+    """
+    try:
+        # Parse the file requests
+        try:
+            requests_data = json.loads(file_requests)
+        except json.JSONDecodeError as e:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": f"Invalid JSON format for file_requests: {str(e)}",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        # Normalize requests format
+        if isinstance(requests_data, list):
+            # Convert simple array to dict format
+            normalized_requests = {file_path: {} for file_path in requests_data}
+        elif isinstance(requests_data, dict):
+            normalized_requests = requests_data
+        else:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": "file_requests must be a JSON object or array",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        # Validate input
+        if len(normalized_requests) == 0:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": "No files provided for reading",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        if len(normalized_requests) > max_files:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": f"Too many files provided ({len(normalized_requests)}), maximum is {max_files}",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        # Process each file
+        results = {
+            "status": "success",
+            "message": f"Successfully processed {len(normalized_requests)} files",
+            "operation_type": "multi_file",
+            "timestamp": datetime.now().isoformat(),
+            "files_processed": len(normalized_requests),
+            "files": {},
+            "summary": {
+                "successful": 0,
+                "failed": 0,
+                "total_size_bytes": 0,
+                "total_lines": 0,
+                "files_not_found": 0,
+            },
+        }
+
+        # Process each file individually
+        for file_path, options in normalized_requests.items():
+            try:
+                full_path = validate_path(file_path)
+                start_line = options.get("start_line")
+                end_line = options.get("end_line")
+
+                if not full_path.exists():
+                    results["files"][file_path] = {
+                        "status": "error",
+                        "message": f"File does not exist: {file_path}",
+                        "file_path": file_path,
+                        "content": "",
+                        "total_lines": 0,
+                        "size_bytes": 0,
+                        "start_line": start_line,
+                        "end_line": end_line,
+                    }
+                    results["summary"]["failed"] += 1
+                    results["summary"]["files_not_found"] += 1
+                    continue
+
+                with open(full_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+
+                # Handle line range
+                original_line_count = len(lines)
+                if start_line is not None or end_line is not None:
+                    start_idx = (start_line - 1) if start_line else 0
+                    end_idx = end_line if end_line else len(lines)
+                    lines = lines[start_idx:end_idx]
+
+                content = "".join(lines)
+                size_bytes = len(content.encode("utf-8"))
+                lines_count = len(lines)
+
+                # Record individual file result
+                results["files"][file_path] = {
+                    "status": "success",
+                    "message": f"File read successfully: {file_path}",
+                    "file_path": file_path,
+                    "content": content,
+                    "total_lines": lines_count,
+                    "original_total_lines": original_line_count,
+                    "size_bytes": size_bytes,
+                    "start_line": start_line,
+                    "end_line": end_line,
+                    "line_range_applied": start_line is not None
+                    or end_line is not None,
+                }
+
+                # Update summary
+                results["summary"]["successful"] += 1
+                results["summary"]["total_size_bytes"] += size_bytes
+                results["summary"]["total_lines"] += lines_count
+
+                # Log individual file operation
+                log_operation(
+                    "read_file_multi",
+                    {
+                        "file_path": file_path,
+                        "start_line": start_line,
+                        "end_line": end_line,
+                        "lines_read": lines_count,
+                        "size_bytes": size_bytes,
+                        "batch_operation": True,
+                    },
+                )
+
+            except Exception as file_error:
+                # Record individual file error
+                results["files"][file_path] = {
+                    "status": "error",
+                    "message": f"Failed to read file: {str(file_error)}",
+                    "file_path": file_path,
+                    "content": "",
+                    "total_lines": 0,
+                    "size_bytes": 0,
+                    "start_line": options.get("start_line"),
+                    "end_line": options.get("end_line"),
+                }
+
+                results["summary"]["failed"] += 1
+
+                # Log individual file error
+                log_operation(
+                    "read_file_multi_error",
+                    {
+                        "file_path": file_path,
+                        "error": str(file_error),
+                        "batch_operation": True,
+                    },
+                )
+
+        # Determine overall status
+        if results["summary"]["failed"] > 0:
+            if results["summary"]["successful"] > 0:
+                results["status"] = "partial_success"
+                results["message"] = (
+                    f"Read {results['summary']['successful']} files successfully, {results['summary']['failed']} failed"
+                )
+            else:
+                results["status"] = "failed"
+                results["message"] = (
+                    f"All {results['summary']['failed']} files failed to read"
+                )
+
+        # Log overall operation
+        log_operation(
+            "read_multiple_files",
+            {
+                "files_count": len(normalized_requests),
+                "successful": results["summary"]["successful"],
+                "failed": results["summary"]["failed"],
+                "total_size_bytes": results["summary"]["total_size_bytes"],
+                "status": results["status"],
+            },
+        )
+
+        return json.dumps(results, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to read multiple files: {str(e)}",
+            "operation_type": "multi_file",
+            "timestamp": datetime.now().isoformat(),
+            "files_processed": 0,
+        }
+        log_operation("read_multiple_files_error", {"error": str(e)})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+async def write_file(
+    file_path: str, content: str, create_dirs: bool = True, create_backup: bool = False
+) -> str:
+    """
+    Write content to file
+
+    Args:
+        file_path: File path, relative to workspace
+        content: Content to write to file
+        create_dirs: Whether to create directories if they don't exist
+        create_backup: Whether to create backup file if file already exists
+
+    Returns:
+        JSON string of operation result
+    """
+    try:
+        full_path = validate_path(file_path)
+
+        # Create directories (if needed)
+        if create_dirs:
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Backup existing file (only when explicitly requested)
+        backup_created = False
+        if full_path.exists() and create_backup:
+            backup_path = full_path.with_suffix(full_path.suffix + ".backup")
+            shutil.copy2(full_path, backup_path)
+            backup_created = True
+
+        # Write file
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        # Update current file record
+        CURRENT_FILES[file_path] = {
+            "last_modified": datetime.now().isoformat(),
+            "size_bytes": len(content.encode("utf-8")),
+            "lines": len(content.split("\n")),
+        }
+
+        result = {
+            "status": "success",
+            "message": f"File written successfully: {file_path}",
+            "file_path": file_path,
+            "size_bytes": len(content.encode("utf-8")),
+            "lines_written": len(content.split("\n")),
+            "backup_created": backup_created,
+        }
+
+        log_operation(
+            "write_file",
+            {
+                "file_path": file_path,
+                "size_bytes": len(content.encode("utf-8")),
+                "lines": len(content.split("\n")),
+                "backup_created": backup_created,
+            },
+        )
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to write file: {str(e)}",
+            "file_path": file_path,
+        }
+        log_operation("write_file_error", {"file_path": file_path, "error": str(e)})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+async def write_multiple_files(
+    file_implementations: str,
+    create_dirs: bool = True,
+    create_backup: bool = False,
+    max_files: int = 5,
+) -> str:
+    """
+    Write multiple files in a single operation (for batch implementation)
+
+    Args:
+        file_implementations: JSON string mapping file paths to content, e.g.,
+                            '{"file1.py": "content1", "file2.py": "content2"}'
+        create_dirs: Whether to create directories if they don't exist
+        create_backup: Whether to create backup files if they already exist
+        max_files: Maximum number of files to write in one operation (default: 5)
+
+    Returns:
+        JSON string of operation results for all files
+    """
+    try:
+        # Parse the file implementations
+        try:
+            files_dict = json.loads(file_implementations)
+        except json.JSONDecodeError as e:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": f"Invalid JSON format for file_implementations: {str(e)}",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        # Validate input
+        if not isinstance(files_dict, dict):
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": "file_implementations must be a JSON object mapping file paths to content",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        if len(files_dict) == 0:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": "No files provided for writing",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        if len(files_dict) > max_files:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": f"Too many files provided ({len(files_dict)}), maximum is {max_files}",
+                    "operation_type": "multi_file",
+                    "timestamp": datetime.now().isoformat(),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        # Process each file
+        results = {
+            "status": "success",
+            "message": f"Successfully processed {len(files_dict)} files",
+            "operation_type": "multi_file",
+            "timestamp": datetime.now().isoformat(),
+            "files_processed": len(files_dict),
+            "files": {},
+            "summary": {
+                "successful": 0,
+                "failed": 0,
+                "total_size_bytes": 0,
+                "total_lines": 0,
+                "backups_created": 0,
+            },
+        }
+
+        # Process each file individually
+        for file_path, content in files_dict.items():
+            try:
+                full_path = validate_path(file_path)
+
+                # Create directories (if needed)
+                if create_dirs:
+                    full_path.parent.mkdir(parents=True, exist_ok=True)
+
+                # Backup existing file (only when explicitly requested)
+                backup_created = False
+                if full_path.exists() and create_backup:
+                    backup_path = full_path.with_suffix(full_path.suffix + ".backup")
+                    shutil.copy2(full_path, backup_path)
+                    backup_created = True
+                    results["summary"]["backups_created"] += 1
+
+                # Write file
+                with open(full_path, "w", encoding="utf-8") as f:
+                    f.write(content)
+
+                # Calculate file metrics
+                size_bytes = len(content.encode("utf-8"))
+                lines_count = len(content.split("\n"))
+
+                # Update current file record
+                CURRENT_FILES[file_path] = {
+                    "last_modified": datetime.now().isoformat(),
+                    "size_bytes": size_bytes,
+                    "lines": lines_count,
+                }
+
+                # Record individual file result
+                results["files"][file_path] = {
+                    "status": "success",
+                    "message": f"File written successfully: {file_path}",
+                    "size_bytes": size_bytes,
+                    "lines_written": lines_count,
+                    "backup_created": backup_created,
+                }
+
+                # Update summary
+                results["summary"]["successful"] += 1
+                results["summary"]["total_size_bytes"] += size_bytes
+                results["summary"]["total_lines"] += lines_count
+
+                # Log individual file operation
+                log_operation(
+                    "write_file_multi",
+                    {
+                        "file_path": file_path,
+                        "size_bytes": size_bytes,
+                        "lines": lines_count,
+                        "backup_created": backup_created,
+                        "batch_operation": True,
+                    },
+                )
+
+            except Exception as file_error:
+                # Record individual file error
+                results["files"][file_path] = {
+                    "status": "error",
+                    "message": f"Failed to write file: {str(file_error)}",
+                    "size_bytes": 0,
+                    "lines_written": 0,
+                    "backup_created": False,
+                }
+
+                results["summary"]["failed"] += 1
+
+                # Log individual file error
+                log_operation(
+                    "write_file_multi_error",
+                    {
+                        "file_path": file_path,
+                        "error": str(file_error),
+                        "batch_operation": True,
+                    },
+                )
+
+        # Determine overall status
+        if results["summary"]["failed"] > 0:
+            if results["summary"]["successful"] > 0:
+                results["status"] = "partial_success"
+                results["message"] = (
+                    f"Processed {results['summary']['successful']} files successfully, {results['summary']['failed']} failed"
+                )
+            else:
+                results["status"] = "failed"
+                results["message"] = (
+                    f"All {results['summary']['failed']} files failed to write"
+                )
+
+        # Log overall operation
+        log_operation(
+            "write_multiple_files",
+            {
+                "files_count": len(files_dict),
+                "successful": results["summary"]["successful"],
+                "failed": results["summary"]["failed"],
+                "total_size_bytes": results["summary"]["total_size_bytes"],
+                "status": results["status"],
+            },
+        )
+
+        return json.dumps(results, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to write multiple files: {str(e)}",
+            "operation_type": "multi_file",
+            "timestamp": datetime.now().isoformat(),
+            "files_processed": 0,
+        }
+        log_operation("write_multiple_files_error", {"error": str(e)})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+# ==================== Code Execution Tools ====================
+
+
+@mcp.tool()
+async def execute_python(code: str, timeout: int = 30) -> str:
+    """
+    Execute Python code and return output
+
+    Args:
+        code: Python code to execute
+        timeout: Timeout in seconds
+
+    Returns:
+        JSON string of execution result
+    """
+    try:
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", delete=False, encoding="utf-8"
+        ) as f:
+            f.write(code)
+            temp_file = f.name
+
+        try:
+            # Ensure workspace directory exists
+            ensure_workspace_exists()
+
+            # Execute Python code
+            result = subprocess.run(
+                [sys.executable, temp_file],
+                cwd=WORKSPACE_DIR,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                encoding="utf-8",
+            )
+
+            execution_result = {
+                "status": "success" if result.returncode == 0 else "error",
+                "return_code": result.returncode,
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "timeout": timeout,
+            }
+
+            if result.returncode != 0:
+                execution_result["message"] = "Python code execution failed"
+            else:
+                execution_result["message"] = "Python code execution successful"
+
+            log_operation(
+                "execute_python",
+                {
+                    "return_code": result.returncode,
+                    "stdout_length": len(result.stdout),
+                    "stderr_length": len(result.stderr),
+                },
+            )
+
+            return json.dumps(execution_result, ensure_ascii=False, indent=2)
+
+        finally:
+            # Clean up temporary file
+            os.unlink(temp_file)
+
+    except subprocess.TimeoutExpired:
+        result = {
+            "status": "error",
+            "message": f"Python code execution timeout ({timeout}秒)",
+            "timeout": timeout,
+        }
+        log_operation("execute_python_timeout", {"timeout": timeout})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Python code execution failed: {str(e)}",
+        }
+        log_operation("execute_python_error", {"error": str(e)})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+async def execute_bash(command: str, timeout: int = 30) -> str:
+    """
+    Execute bash command
+
+    Args:
+        command: Bash command to execute
+        timeout: Timeout in seconds
+
+    Returns:
+        JSON string of execution result
+    """
+    try:
+        # 安全检查：禁止危险命令
+        dangerous_commands = ["rm -rf", "sudo", "chmod 777", "mkfs", "dd if="]
+        if any(dangerous in command.lower() for dangerous in dangerous_commands):
+            result = {
+                "status": "error",
+                "message": f"Dangerous command execution prohibited: {command}",
+            }
+            log_operation(
+                "execute_bash_blocked",
+                {"command": command, "reason": "dangerous_command"},
+            )
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        # Ensure workspace directory exists
+        ensure_workspace_exists()
+
+        # Execute command
+        result = subprocess.run(
+            command,
+            shell=True,
+            cwd=WORKSPACE_DIR,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            encoding="utf-8",
+        )
+
+        execution_result = {
+            "status": "success" if result.returncode == 0 else "error",
+            "return_code": result.returncode,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "command": command,
+            "timeout": timeout,
+        }
+
+        if result.returncode != 0:
+            execution_result["message"] = "Bash command execution failed"
+        else:
+            execution_result["message"] = "Bash command execution successful"
+
+        log_operation(
+            "execute_bash",
+            {
+                "command": command,
+                "return_code": result.returncode,
+                "stdout_length": len(result.stdout),
+                "stderr_length": len(result.stderr),
+            },
+        )
+
+        return json.dumps(execution_result, ensure_ascii=False, indent=2)
+
+    except subprocess.TimeoutExpired:
+        result = {
+            "status": "error",
+            "message": f"Bash command execution timeout ({timeout} seconds)",
+            "command": command,
+            "timeout": timeout,
+        }
+        log_operation("execute_bash_timeout", {"command": command, "timeout": timeout})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to execute bash command: {str(e)}",
+            "command": command,
+        }
+        log_operation("execute_bash_error", {"command": command, "error": str(e)})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+async def read_code_mem(file_paths: List[str]) -> str:
+    """
+    Check if file summaries exist in implement_code_summary.md for multiple files
+
+    Args:
+        file_paths: List of file paths to check for summary information in implement_code_summary.md
+
+    Returns:
+        Summary information for all requested files if available
+    """
+    try:
+        if not file_paths or not isinstance(file_paths, list):
+            result = {
+                "status": "error",
+                "message": "file_paths parameter is required and must be a list",
+            }
+            log_operation(
+                "read_code_mem_error", {"error": "missing_or_invalid_file_paths"}
+            )
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        # Remove duplicates while preserving order
+        unique_file_paths = list(dict.fromkeys(file_paths))
+
+        # Ensure workspace exists
+        ensure_workspace_exists()
+
+        # Look for implement_code_summary.md in the workspace
+        current_path = Path(WORKSPACE_DIR)
+        summary_file_path = current_path.parent / "implement_code_summary.md"
+
+        if not summary_file_path.exists():
+            result = {
+                "status": "no_summary",
+                "file_paths": unique_file_paths,
+                "message": "No summary file found.",
+                "results": [],
+            }
+            log_operation(
+                "read_code_mem",
+                {"file_paths": unique_file_paths, "status": "no_summary_file"},
+            )
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        # Read the summary file
+        with open(summary_file_path, "r", encoding="utf-8") as f:
+            summary_content = f.read()
+
+        if not summary_content.strip():
+            result = {
+                "status": "no_summary",
+                "file_paths": unique_file_paths,
+                "message": "Summary file is empty.",
+                "results": [],
+            }
+            log_operation(
+                "read_code_mem",
+                {"file_paths": unique_file_paths, "status": "empty_summary"},
+            )
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        # Process each file path and collect results
+        results = []
+        summaries_found = 0
+
+        for file_path in unique_file_paths:
+            # Extract file-specific section from summary
+            file_section = _extract_file_section_from_summary(
+                summary_content, file_path
+            )
+
+            if file_section:
+                file_result = {
+                    "file_path": file_path,
+                    "status": "summary_found",
+                    "summary_content": file_section,
+                    "message": f"Summary information found for {file_path}",
+                }
+                summaries_found += 1
+            else:
+                file_result = {
+                    "file_path": file_path,
+                    "status": "no_summary",
+                    "summary_content": None,
+                    "message": f"No summary found for {file_path}",
+                }
+
+            results.append(file_result)
+
+        # Determine overall status
+        if summaries_found == len(unique_file_paths):
+            overall_status = "all_summaries_found"
+        elif summaries_found > 0:
+            overall_status = "partial_summaries_found"
+        else:
+            overall_status = "no_summaries_found"
+
+        result = {
+            "status": overall_status,
+            "file_paths": unique_file_paths,
+            "total_requested": len(unique_file_paths),
+            "summaries_found": summaries_found,
+            "message": f"Found summaries for {summaries_found}/{len(unique_file_paths)} files",
+            "results": results,
+        }
+
+        log_operation(
+            "read_code_mem",
+            {
+                "file_paths": unique_file_paths,
+                "status": overall_status,
+                "total_requested": len(unique_file_paths),
+                "summaries_found": summaries_found,
+            },
+        )
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to check code memory: {str(e)}",
+            "file_paths": file_paths
+            if isinstance(file_paths, list)
+            else [str(file_paths)],
+            "results": [],
+        }
+        log_operation(
+            "read_code_mem_error", {"file_paths": file_paths, "error": str(e)}
+        )
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+def _extract_file_section_from_summary(
+    summary_content: str, target_file_path: str
+) -> str:
+    """
+    Extract the specific section for a file from the summary content
+
+    Args:
+        summary_content: Full summary content
+        target_file_path: Path of the target file
+
+    Returns:
+        File-specific section or None if not found
+    """
+    import re
+
+    # Normalize the target path for comparison
+    normalized_target = _normalize_file_path(target_file_path)
+
+    # Pattern to match implementation sections with separator lines
+    section_pattern = r"={80}\s*\n## IMPLEMENTATION File ([^;]+); ROUND \d+\s*\n={80}(.*?)(?=\n={80}|\Z)"
+
+    matches = re.findall(section_pattern, summary_content, re.DOTALL)
+
+    for file_path_in_summary, section_content in matches:
+        file_path_in_summary = file_path_in_summary.strip()
+        section_content = section_content.strip()
+
+        # Normalize the path from summary for comparison
+        normalized_summary_path = _normalize_file_path(file_path_in_summary)
+
+        # Check if paths match using multiple strategies
+        if _paths_match(
+            normalized_target,
+            normalized_summary_path,
+            target_file_path,
+            file_path_in_summary,
+        ):
+            # Return the complete section with proper formatting
+            file_section = f"""================================================================================
+## IMPLEMENTATION File {file_path_in_summary}; ROUND [X]
+================================================================================
+
+{section_content}
+
+---
+*Extracted from implement_code_summary.md*"""
+            return file_section
+
+    # If no section-based match, try alternative parsing method
+    return _extract_file_section_alternative(summary_content, target_file_path)
+
+
+def _normalize_file_path(file_path: str) -> str:
+    """Normalize file path for comparison"""
+    # Remove leading/trailing slashes and convert to lowercase
+    normalized = file_path.strip("/").lower()
+    # Replace backslashes with forward slashes
+    normalized = normalized.replace("\\", "/")
+
+    # Remove common prefixes to make matching more flexible
+    common_prefixes = ["src/", "./src/", "./", "core/", "lib/", "main/"]
+    for prefix in common_prefixes:
+        if normalized.startswith(prefix):
+            normalized = normalized[len(prefix) :]
+            break
+
+    return normalized
+
+
+def _paths_match(
+    normalized_target: str,
+    normalized_summary: str,
+    original_target: str,
+    original_summary: str,
+) -> bool:
+    """Check if two file paths match using multiple strategies"""
+
+    # Strategy 1: Exact normalized match
+    if normalized_target == normalized_summary:
+        return True
+
+    # Strategy 2: Basename match (filename only)
+    target_basename = os.path.basename(original_target)
+    summary_basename = os.path.basename(original_summary)
+    if target_basename == summary_basename and len(target_basename) > 4:
+        return True
+
+    # Strategy 3: Suffix match (remove common prefixes and compare)
+    target_suffix = _remove_common_prefixes(normalized_target)
+    summary_suffix = _remove_common_prefixes(normalized_summary)
+    if target_suffix == summary_suffix:
+        return True
+
+    # Strategy 4: Ends with match
+    if normalized_target.endswith(normalized_summary) or normalized_summary.endswith(
+        normalized_target
+    ):
+        return True
+
+    # Strategy 5: Contains match for longer paths
+    if len(normalized_target) > 10 and normalized_target in normalized_summary:
+        return True
+    if len(normalized_summary) > 10 and normalized_summary in normalized_target:
+        return True
+
+    return False
+
+
+def _remove_common_prefixes(file_path: str) -> str:
+    """Remove common prefixes from file path"""
+    prefixes_to_remove = ["src/", "core/", "./", "lib/", "main/"]
+    path = file_path
+
+    for prefix in prefixes_to_remove:
+        if path.startswith(prefix):
+            path = path[len(prefix) :]
+
+    return path
+
+
+def _extract_file_section_alternative(
+    summary_content: str, target_file_path: str
+) -> str:
+    """Alternative method to extract file section using simpler pattern matching"""
+
+    # Get the basename for fallback matching
+    target_basename = os.path.basename(target_file_path)
+
+    # Split by separator lines to get individual sections
+    sections = summary_content.split("=" * 80)
+
+    for i, section in enumerate(sections):
+        if "## IMPLEMENTATION File" in section:
+            # Extract the file path from the header
+            lines = section.strip().split("\n")
+            for line in lines:
+                if "## IMPLEMENTATION File" in line:
+                    # Extract file path between "File " and "; ROUND"
+                    try:
+                        file_part = line.split("File ")[1].split("; ROUND")[0].strip()
+
+                        # Check if this matches our target
+                        if (
+                            _normalize_file_path(target_file_path)
+                            == _normalize_file_path(file_part)
+                            or target_basename == os.path.basename(file_part)
+                            or target_file_path in file_part
+                            or file_part.endswith(target_file_path)
+                        ):
+                            # Get the next section which contains the content
+                            if i + 1 < len(sections):
+                                content_section = sections[i + 1].strip()
+                                return f"""================================================================================
+## IMPLEMENTATION File {file_part}
+================================================================================
+
+{content_section}
+
+---
+*Extracted from implement_code_summary.md using alternative method*"""
+                    except (IndexError, AttributeError):
+                        continue
+
+    return None
+
+
+# ==================== Code Search Tools ====================
+
+
+@mcp.tool()
+async def search_code(
+    pattern: str,
+    file_pattern: str = "*.json",
+    use_regex: bool = False,
+    search_directory: str = None,
+) -> str:
+    """
+    Search patterns in code files
+
+    Args:
+        pattern: Search pattern
+        file_pattern: File pattern (e.g., '*.py')
+        use_regex: Whether to use regular expressions
+        search_directory: Specify search directory (optional, uses WORKSPACE_DIR if not specified)
+
+    Returns:
+        JSON string of search results
+    """
+    try:
+        # Determine search directory
+        if search_directory:
+            # If search directory is specified, use the specified directory
+            if os.path.isabs(search_directory):
+                search_path = Path(search_directory)
+            else:
+                # Relative path, relative to current working directory
+                search_path = Path.cwd() / search_directory
+        else:
+            # 如果没有指定Search directory，使用默认的WORKSPACE_DIR
+            ensure_workspace_exists()
+            search_path = WORKSPACE_DIR
+
+        # 检查Search directory是否存在
+        if not search_path.exists():
+            result = {
+                "status": "error",
+                "message": f"Search directory不存在: {search_path}",
+                "pattern": pattern,
+            }
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        import glob
+
+        # Get matching files
+        file_paths = glob.glob(str(search_path / "**" / file_pattern), recursive=True)
+
+        matches = []
+        total_files_searched = 0
+
+        for file_path in file_paths:
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+
+                total_files_searched += 1
+                relative_path = os.path.relpath(file_path, search_path)
+
+                for line_num, line in enumerate(lines, 1):
+                    if use_regex:
+                        if re.search(pattern, line):
+                            matches.append(
+                                {
+                                    "file": relative_path,
+                                    "line_number": line_num,
+                                    "line_content": line.strip(),
+                                    "match_type": "regex",
+                                }
+                            )
+                    else:
+                        if pattern.lower() in line.lower():
+                            matches.append(
+                                {
+                                    "file": relative_path,
+                                    "line_number": line_num,
+                                    "line_content": line.strip(),
+                                    "match_type": "substring",
+                                }
+                            )
+
+            except Exception as e:
+                logger.warning(f"Error searching file {file_path}: {e}")
+                continue
+
+        result = {
+            "status": "success",
+            "pattern": pattern,
+            "file_pattern": file_pattern,
+            "use_regex": use_regex,
+            "search_directory": str(search_path),
+            "total_matches": len(matches),
+            "total_files_searched": total_files_searched,
+            "matches": matches[:50],  # 限制返回前50个匹配
+        }
+
+        if len(matches) > 50:
+            result["note"] = f"显示前50个匹配，总共找到{len(matches)}个匹配"
+
+        log_operation(
+            "search_code",
+            {
+                "pattern": pattern,
+                "file_pattern": file_pattern,
+                "use_regex": use_regex,
+                "search_directory": str(search_path),
+                "total_matches": len(matches),
+                "files_searched": total_files_searched,
+            },
+        )
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Code search failed: {str(e)}",
+            "pattern": pattern,
+        }
+        log_operation("search_code_error", {"pattern": pattern, "error": str(e)})
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+# ==================== File Structure Tools ====================
+
+
+@mcp.tool()
+async def get_file_structure(directory: str = ".", max_depth: int = 5) -> str:
+    """
+    Get directory file structure
+
+    Args:
+        directory: Directory path, relative to workspace
+        max_depth: 最大遍历深度
+
+    Returns:
+        JSON string of file structure
+    """
+    try:
+        ensure_workspace_exists()
+
+        if directory == ".":
+            target_dir = WORKSPACE_DIR
+        else:
+            target_dir = validate_path(directory)
+
+        if not target_dir.exists():
+            result = {
+                "status": "error",
+                "message": f"Directory does not exist: {directory}",
+            }
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        def scan_directory(path: Path, current_depth: int = 0) -> Dict[str, Any]:
+            """Recursively scan directory"""
+            if current_depth >= max_depth:
+                return {"type": "directory", "name": path.name, "truncated": True}
+
+            items = []
+            try:
+                for item in sorted(path.iterdir()):
+                    relative_path = os.path.relpath(item, WORKSPACE_DIR)
+
+                    if item.is_file():
+                        file_info = {
+                            "type": "file",
+                            "name": item.name,
+                            "path": relative_path,
+                            "size_bytes": item.stat().st_size,
+                            "extension": item.suffix,
+                        }
+                        items.append(file_info)
+                    elif item.is_dir() and not item.name.startswith("."):
+                        dir_info = scan_directory(item, current_depth + 1)
+                        dir_info["path"] = relative_path
+                        items.append(dir_info)
+            except PermissionError:
+                pass
+
+            return {
+                "type": "directory",
+                "name": path.name,
+                "items": items,
+                "item_count": len(items),
+            }
+
+        structure = scan_directory(target_dir)
+
+        # 统计信息
+        def count_items(node):
+            if node["type"] == "file":
+                return {"files": 1, "directories": 0}
+            else:
+                counts = {"files": 0, "directories": 1}
+                for item in node.get("items", []):
+                    item_counts = count_items(item)
+                    counts["files"] += item_counts["files"]
+                    counts["directories"] += item_counts["directories"]
+                return counts
+
+        counts = count_items(structure)
+
+        result = {
+            "status": "success",
+            "directory": directory,
+            "max_depth": max_depth,
+            "structure": structure,
+            "summary": {
+                "total_files": counts["files"],
+                "total_directories": counts["directories"]
+                - 1,  # Exclude root directory
+            },
+        }
+
+        log_operation(
+            "get_file_structure",
+            {
+                "directory": directory,
+                "max_depth": max_depth,
+                "total_files": counts["files"],
+                "total_directories": counts["directories"] - 1,
+            },
+        )
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to get file structure: {str(e)}",
+            "directory": directory,
+        }
+        log_operation(
+            "get_file_structure_error", {"directory": directory, "error": str(e)}
+        )
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+# ==================== Workspace Management Tools ====================
+
+
+@mcp.tool()
+async def set_workspace(workspace_path: str) -> str:
+    """
+    Set workspace directory
+
+    Called by workflow to set workspace to: {plan_file_parent}/generate_code
+    This ensures all file operations are executed relative to the correct project directory
+
+    Args:
+        workspace_path: Workspace path (Usually {plan_file_parent}/generate_code)
+
+    Returns:
+        JSON string of operation result
+    """
+    try:
+        global WORKSPACE_DIR
+        new_workspace = Path(workspace_path).resolve()
+
+        # Create directory (if it does not exist)
+        new_workspace.mkdir(parents=True, exist_ok=True)
+
+        old_workspace = WORKSPACE_DIR
+        WORKSPACE_DIR = new_workspace
+
+        logger.info(f"New Workspace: {WORKSPACE_DIR}")
+
+        result = {
+            "status": "success",
+            "message": f"Workspace setup successful: {workspace_path}",
+            "new_workspace": str(WORKSPACE_DIR),
+        }
+
+        log_operation(
+            "set_workspace",
+            {
+                "old_workspace": str(old_workspace) if old_workspace else None,
+                "new_workspace": str(WORKSPACE_DIR),
+                "workspace_alignment": "plan_file_parent/generate_code",
+            },
+        )
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to set workspace: {str(e)}",
+            "workspace_path": workspace_path,
+        }
+        log_operation(
+            "set_workspace_error", {"workspace_path": workspace_path, "error": str(e)}
+        )
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+async def get_operation_history(last_n: int = 10) -> str:
+    """
+    Get operation history
+
+    Args:
+        last_n: Return the last N operations
+
+    Returns:
+        JSON string of operation history
+    """
+    try:
+        recent_history = (
+            OPERATION_HISTORY[-last_n:] if last_n > 0 else OPERATION_HISTORY
+        )
+
+        result = {
+            "status": "success",
+            "total_operations": len(OPERATION_HISTORY),
+            "returned_operations": len(recent_history),
+            "workspace": str(WORKSPACE_DIR) if WORKSPACE_DIR else None,
+            "history": recent_history,
+        }
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to get operation history: {str(e)}",
+        }
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+# ==================== Server Initialization ====================
+
+
+def main():
+    """Start MCP server"""
+    print("🚀 Code Implementation MCP Server")
+    print(
+        "📝 Paper Code Implementation Tool Server / Paper Code Implementation Tool Server"
+    )
+    print("")
+    print("Available tools / Available tools:")
+    # print("  • read_file           - Read file contents / Read file contents")
+    print(
+        "  • read_code_mem       - Read code summary from implement_code_summary.md / Read code summary from implement_code_summary.md"
+    )
+    print("  • write_file          - Write file contents / Write file contents")
+    print("  • execute_python      - Execute Python code / Execute Python code")
+    print("  • execute_bash        - Execute bash command / Execute bash commands")
+    print("  • search_code         - Search code patterns / Search code patterns")
+    print("  • get_file_structure  - Get file structure / Get file structure")
+    print("  • set_workspace       - Set workspace / Set workspace")
+    print("  • get_operation_history - Get operation history / Get operation history")
+    print("")
+    print("🔧 Server starting...")
+
+    # Initialize default workspace
+    initialize_workspace()
+
+    # Start server
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

projects/ui/DeepCode/tools/code_indexer.py

@@ -0,0 +1,1677 @@
+"""
+Code Indexer for Repository Analysis
+
+Analyzes code repositories to build comprehensive indexes for each subdirectory,
+identifying file relationships and reusable components for implementation.
+
+Features:
+- Recursive file traversal
+- LLM-powered code similarity analysis using augmented LLM classes
+- JSON-based relationship storage
+- Configurable matching strategies
+- Progress tracking and error handling
+- Automatic LLM provider selection based on API key availability
+"""
+
+import asyncio
+import json
+import logging
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from typing import List, Dict, Any
+
+# MCP Agent imports for LLM
+import yaml
+from utils.llm_utils import get_preferred_llm_class
+
+
+def get_default_models(config_path: str = "mcp_agent.config.yaml"):
+    """
+    Get default models from configuration file.
+
+    Args:
+        config_path: Path to the configuration file
+
+    Returns:
+        dict: Dictionary with 'anthropic' and 'openai' default models
+    """
+    try:
+        if os.path.exists(config_path):
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+
+            anthropic_model = config.get("anthropic", {}).get(
+                "default_model", "claude-sonnet-4-20250514"
+            )
+            openai_model = config.get("openai", {}).get("default_model", "o3-mini")
+
+            return {"anthropic": anthropic_model, "openai": openai_model}
+        else:
+            print(f"Config file {config_path} not found, using default models")
+            return {"anthropic": "claude-sonnet-4-20250514", "openai": "o3-mini"}
+
+    except Exception as e:
+        print(f"Error reading config file {config_path}: {e}")
+        return {"anthropic": "claude-sonnet-4-20250514", "openai": "o3-mini"}
+
+
+@dataclass
+class FileRelationship:
+    """Represents a relationship between a repo file and target structure file"""
+
+    repo_file_path: str
+    target_file_path: str
+    relationship_type: str  # 'direct_match', 'partial_match', 'reference', 'utility'
+    confidence_score: float  # 0.0 to 1.0
+    helpful_aspects: List[str]
+    potential_contributions: List[str]
+    usage_suggestions: str
+
+
+@dataclass
+class FileSummary:
+    """Summary information for a repository file"""
+
+    file_path: str
+    file_type: str
+    main_functions: List[str]
+    key_concepts: List[str]
+    dependencies: List[str]
+    summary: str
+    lines_of_code: int
+    last_modified: str
+
+
+@dataclass
+class RepoIndex:
+    """Complete index for a repository"""
+
+    repo_name: str
+    total_files: int
+    file_summaries: List[FileSummary]
+    relationships: List[FileRelationship]
+    analysis_metadata: Dict[str, Any]
+
+
+class CodeIndexer:
+    """Main class for building code repository indexes"""
+
+    def __init__(
+        self,
+        code_base_path: str = None,
+        target_structure: str = None,
+        output_dir: str = None,
+        config_path: str = "mcp_agent.secrets.yaml",
+        indexer_config_path: str = None,
+        enable_pre_filtering: bool = True,
+    ):
+        # Load configurations first
+        self.config_path = config_path
+        self.indexer_config_path = indexer_config_path
+        self.api_config = self._load_api_config()
+        self.indexer_config = self._load_indexer_config()
+        self.default_models = get_default_models("mcp_agent.config.yaml")
+
+        # Use config paths if not provided as parameters
+        paths_config = self.indexer_config.get("paths", {})
+        self.code_base_path = Path(
+            code_base_path or paths_config.get("code_base_path", "code_base")
+        )
+        self.output_dir = Path(output_dir or paths_config.get("output_dir", "indexes"))
+        self.target_structure = (
+            target_structure  # This must be provided as it's project-specific
+        )
+        self.enable_pre_filtering = enable_pre_filtering
+
+        # LLM clients
+        self.llm_client = None
+        self.llm_client_type = None
+
+        # Initialize logger early
+        self.logger = self._setup_logger()
+
+        # Create output directory if it doesn't exist
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load file analysis configuration
+        file_analysis_config = self.indexer_config.get("file_analysis", {})
+        self.supported_extensions = set(
+            file_analysis_config.get(
+                "supported_extensions",
+                [
+                    ".py",
+                    ".js",
+                    ".ts",
+                    ".java",
+                    ".cpp",
+                    ".c",
+                    ".h",
+                    ".hpp",
+                    ".cs",
+                    ".php",
+                    ".rb",
+                    ".go",
+                    ".rs",
+                    ".scala",
+                    ".kt",
+                    ".swift",
+                    ".m",
+                    ".mm",
+                    ".r",
+                    ".matlab",
+                    ".sql",
+                    ".sh",
+                    ".bat",
+                    ".ps1",
+                    ".yaml",
+                    ".yml",
+                    ".json",
+                    ".xml",
+                    ".toml",
+                ],
+            )
+        )
+
+        self.skip_directories = set(
+            file_analysis_config.get(
+                "skip_directories",
+                [
+                    "__pycache__",
+                    "node_modules",
+                    "target",
+                    "build",
+                    "dist",
+                    "venv",
+                    "env",
+                ],
+            )
+        )
+
+        self.max_file_size = file_analysis_config.get("max_file_size", 1048576)  # 1MB
+        self.max_content_length = file_analysis_config.get("max_content_length", 3000)
+
+        # Load LLM configuration
+        llm_config = self.indexer_config.get("llm", {})
+        self.model_provider = llm_config.get("model_provider", "anthropic")
+        self.llm_max_tokens = llm_config.get("max_tokens", 4000)
+        self.llm_temperature = llm_config.get("temperature", 0.3)
+        self.llm_system_prompt = llm_config.get(
+            "system_prompt",
+            "You are a code analysis expert. Provide precise, structured analysis of code relationships and similarities.",
+        )
+        self.request_delay = llm_config.get("request_delay", 0.1)
+        self.max_retries = llm_config.get("max_retries", 3)
+        self.retry_delay = llm_config.get("retry_delay", 1.0)
+
+        # Load relationship configuration
+        relationship_config = self.indexer_config.get("relationships", {})
+        self.min_confidence_score = relationship_config.get("min_confidence_score", 0.3)
+        self.high_confidence_threshold = relationship_config.get(
+            "high_confidence_threshold", 0.7
+        )
+        self.relationship_types = relationship_config.get(
+            "relationship_types",
+            {
+                "direct_match": 1.0,
+                "partial_match": 0.8,
+                "reference": 0.6,
+                "utility": 0.4,
+            },
+        )
+
+        # Load performance configuration
+        performance_config = self.indexer_config.get("performance", {})
+        self.enable_concurrent_analysis = performance_config.get(
+            "enable_concurrent_analysis", False
+        )
+        self.max_concurrent_files = performance_config.get("max_concurrent_files", 5)
+        self.enable_content_caching = performance_config.get(
+            "enable_content_caching", False
+        )
+        self.max_cache_size = performance_config.get("max_cache_size", 100)
+
+        # Load debug configuration
+        debug_config = self.indexer_config.get("debug", {})
+        self.save_raw_responses = debug_config.get("save_raw_responses", False)
+        self.raw_responses_dir = debug_config.get(
+            "raw_responses_dir", "debug_responses"
+        )
+        self.verbose_output = debug_config.get("verbose_output", False)
+        self.mock_llm_responses = debug_config.get("mock_llm_responses", False)
+
+        # Load output configuration
+        output_config = self.indexer_config.get("output", {})
+        self.generate_summary = output_config.get("generate_summary", True)
+        self.generate_statistics = output_config.get("generate_statistics", True)
+        self.include_metadata = output_config.get("include_metadata", True)
+        self.index_filename_pattern = output_config.get(
+            "index_filename_pattern", "{repo_name}_index.json"
+        )
+        self.summary_filename = output_config.get(
+            "summary_filename", "indexing_summary.json"
+        )
+        self.stats_filename = output_config.get(
+            "stats_filename", "indexing_statistics.json"
+        )
+
+        # Initialize caching if enabled
+        self.content_cache = {} if self.enable_content_caching else None
+
+        # Create debug directory if needed
+        if self.save_raw_responses:
+            Path(self.raw_responses_dir).mkdir(parents=True, exist_ok=True)
+
+        # Debug logging
+        if self.verbose_output:
+            self.logger.info(
+                f"Initialized CodeIndexer with config: {self.indexer_config_path}"
+            )
+            self.logger.info(f"Code base path: {self.code_base_path}")
+            self.logger.info(f"Output directory: {self.output_dir}")
+            self.logger.info(f"Model provider: {self.model_provider}")
+            self.logger.info(f"Concurrent analysis: {self.enable_concurrent_analysis}")
+            self.logger.info(f"Content caching: {self.enable_content_caching}")
+            self.logger.info(f"Mock LLM responses: {self.mock_llm_responses}")
+
+    def _setup_logger(self) -> logging.Logger:
+        """Setup logging configuration from config file"""
+        logger = logging.getLogger("CodeIndexer")
+
+        # Get logging config
+        logging_config = self.indexer_config.get("logging", {})
+        log_level = logging_config.get("level", "INFO")
+        log_format = logging_config.get(
+            "log_format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+
+        logger.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+        # Clear existing handlers
+        logger.handlers.clear()
+
+        # Console handler
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(log_format)
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+        # File handler if enabled
+        if logging_config.get("log_to_file", False):
+            log_file = logging_config.get("log_file", "indexer.log")
+            file_handler = logging.FileHandler(log_file, encoding="utf-8")
+            file_handler.setFormatter(formatter)
+            logger.addHandler(file_handler)
+
+        return logger
+
+    def _load_api_config(self) -> Dict[str, Any]:
+        """Load API configuration from YAML file"""
+        try:
+            import yaml
+
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        except Exception as e:
+            # Create a basic logger for this error since self.logger doesn't exist yet
+            print(f"Warning: Failed to load API config from {self.config_path}: {e}")
+            return {}
+
+    def _load_indexer_config(self) -> Dict[str, Any]:
+        """Load indexer configuration from YAML file"""
+        try:
+            import yaml
+
+            with open(self.indexer_config_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+                if config is None:
+                    config = {}
+                return config
+        except Exception as e:
+            print(
+                f"Warning: Failed to load indexer config from {self.indexer_config_path}: {e}"
+            )
+            print("Using default configuration values")
+            return {}
+
+    async def _initialize_llm_client(self):
+        """Initialize LLM client (Anthropic or OpenAI) based on API key availability"""
+        if self.llm_client is not None:
+            return self.llm_client, self.llm_client_type
+
+        # Check if mock responses are enabled
+        if self.mock_llm_responses:
+            self.logger.info("Using mock LLM responses for testing")
+            self.llm_client = "mock"
+            self.llm_client_type = "mock"
+            return "mock", "mock"
+
+        # Check which API has available key and try that first
+        anthropic_key = self.api_config.get("anthropic", {}).get("api_key", "")
+        openai_key = self.api_config.get("openai", {}).get("api_key", "")
+
+        # Try Anthropic API first if key is available
+        if anthropic_key and anthropic_key.strip():
+            try:
+                from anthropic import AsyncAnthropic
+
+                client = AsyncAnthropic(api_key=anthropic_key)
+                # Test connection with default model from config
+                await client.messages.create(
+                    model=self.default_models["anthropic"],
+                    max_tokens=10,
+                    messages=[{"role": "user", "content": "test"}],
+                )
+                self.logger.info(
+                    f"Using Anthropic API with model: {self.default_models['anthropic']}"
+                )
+                self.llm_client = client
+                self.llm_client_type = "anthropic"
+                return client, "anthropic"
+            except Exception as e:
+                self.logger.warning(f"Anthropic API unavailable: {e}")
+
+        # Try OpenAI API if Anthropic failed or key not available
+        if openai_key and openai_key.strip():
+            try:
+                from openai import AsyncOpenAI
+
+                # Handle custom base_url if specified
+                openai_config = self.api_config.get("openai", {})
+                base_url = openai_config.get("base_url")
+
+                if base_url:
+                    client = AsyncOpenAI(api_key=openai_key, base_url=base_url)
+                else:
+                    client = AsyncOpenAI(api_key=openai_key)
+
+                # Test connection with default model from config
+                await client.chat.completions.create(
+                    model=self.default_models["openai"],
+                    max_tokens=10,
+                    messages=[{"role": "user", "content": "test"}],
+                )
+                self.logger.info(
+                    f"Using OpenAI API with model: {self.default_models['openai']}"
+                )
+                if base_url:
+                    self.logger.info(f"Using custom base URL: {base_url}")
+                self.llm_client = client
+                self.llm_client_type = "openai"
+                return client, "openai"
+            except Exception as e:
+                self.logger.warning(f"OpenAI API unavailable: {e}")
+
+        raise ValueError(
+            "No available LLM API - please check your API keys in configuration"
+        )
+
+    async def _call_llm(
+        self, prompt: str, system_prompt: str = None, max_tokens: int = None
+    ) -> str:
+        """Call LLM for code analysis with retry mechanism and debugging support"""
+        if system_prompt is None:
+            system_prompt = self.llm_system_prompt
+        if max_tokens is None:
+            max_tokens = self.llm_max_tokens
+
+        # Mock response for testing
+        if self.mock_llm_responses:
+            mock_response = self._generate_mock_response(prompt)
+            if self.save_raw_responses:
+                self._save_debug_response("mock", prompt, mock_response)
+            return mock_response
+
+        last_error = None
+
+        # Retry mechanism
+        for attempt in range(self.max_retries):
+            try:
+                if self.verbose_output and attempt > 0:
+                    self.logger.info(
+                        f"LLM call attempt {attempt + 1}/{self.max_retries}"
+                    )
+
+                client, client_type = await self._initialize_llm_client()
+
+                if client_type == "anthropic":
+                    response = await client.messages.create(
+                        model=self.default_models["anthropic"],
+                        system=system_prompt,
+                        messages=[{"role": "user", "content": prompt}],
+                        max_tokens=max_tokens,
+                        temperature=self.llm_temperature,
+                    )
+
+                    content = ""
+                    for block in response.content:
+                        if block.type == "text":
+                            content += block.text
+
+                    # Save debug response if enabled
+                    if self.save_raw_responses:
+                        self._save_debug_response("anthropic", prompt, content)
+
+                    return content
+
+                elif client_type == "openai":
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": prompt},
+                    ]
+
+                    response = await client.chat.completions.create(
+                        model=self.default_models["openai"],
+                        messages=messages,
+                        max_tokens=max_tokens,
+                        temperature=self.llm_temperature,
+                    )
+
+                    content = response.choices[0].message.content or ""
+
+                    # Save debug response if enabled
+                    if self.save_raw_responses:
+                        self._save_debug_response("openai", prompt, content)
+
+                    return content
+                else:
+                    raise ValueError(f"Unsupported client type: {client_type}")
+
+            except Exception as e:
+                last_error = e
+                self.logger.warning(f"LLM call attempt {attempt + 1} failed: {e}")
+
+                if attempt < self.max_retries - 1:
+                    await asyncio.sleep(
+                        self.retry_delay * (attempt + 1)
+                    )  # Exponential backoff
+
+        # All retries failed
+        error_msg = f"LLM call failed after {self.max_retries} attempts. Last error: {str(last_error)}"
+        self.logger.error(error_msg)
+        return f"Error in LLM analysis: {error_msg}"
+
+    def _generate_mock_response(self, prompt: str) -> str:
+        """Generate mock LLM response for testing"""
+        if "JSON format" in prompt and "file_type" in prompt:
+            # File analysis mock
+            return """
+            {
+                "file_type": "Python module",
+                "main_functions": ["main_function", "helper_function"],
+                "key_concepts": ["data_processing", "algorithm"],
+                "dependencies": ["numpy", "pandas"],
+                "summary": "Mock analysis of code file functionality."
+            }
+            """
+        elif "relationships" in prompt:
+            # Relationship analysis mock
+            return """
+            {
+                "relationships": [
+                    {
+                        "target_file_path": "src/core/mock.py",
+                        "relationship_type": "partial_match",
+                        "confidence_score": 0.8,
+                        "helpful_aspects": ["algorithm implementation", "data structures"],
+                        "potential_contributions": ["core functionality", "utility methods"],
+                        "usage_suggestions": "Mock relationship suggestion for testing."
+                    }
+                ]
+            }
+            """
+        elif "relevant_files" in prompt:
+            # File filtering mock
+            return """
+            {
+                "relevant_files": [
+                    {
+                        "file_path": "mock_file.py",
+                        "relevance_reason": "Mock relevance reason",
+                        "confidence": 0.9,
+                        "expected_contribution": "Mock contribution"
+                    }
+                ],
+                "summary": {
+                    "total_files_analyzed": "10",
+                    "relevant_files_count": "1",
+                    "filtering_strategy": "Mock filtering strategy"
+                }
+            }
+            """
+        else:
+            return "Mock LLM response for testing purposes."
+
+    def _save_debug_response(self, provider: str, prompt: str, response: str):
+        """Save LLM response for debugging"""
+        try:
+            import hashlib
+            from datetime import datetime
+
+            # Create a hash of the prompt for filename
+            prompt_hash = hashlib.md5(prompt.encode()).hexdigest()[:8]
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"{provider}_{timestamp}_{prompt_hash}.json"
+
+            debug_data = {
+                "timestamp": datetime.now().isoformat(),
+                "provider": provider,
+                "prompt": prompt[:500] + "..." if len(prompt) > 500 else prompt,
+                "response": response,
+                "full_prompt_length": len(prompt),
+            }
+
+            debug_file = Path(self.raw_responses_dir) / filename
+            with open(debug_file, "w", encoding="utf-8") as f:
+                json.dump(debug_data, f, indent=2, ensure_ascii=False)
+
+        except Exception as e:
+            self.logger.warning(f"Failed to save debug response: {e}")
+
+    def get_all_repo_files(self, repo_path: Path) -> List[Path]:
+        """Recursively get all supported files in a repository"""
+        files = []
+
+        try:
+            for root, dirs, filenames in os.walk(repo_path):
+                # Skip common non-code directories
+                dirs[:] = [
+                    d
+                    for d in dirs
+                    if not d.startswith(".") and d not in self.skip_directories
+                ]
+
+                for filename in filenames:
+                    file_path = Path(root) / filename
+                    if file_path.suffix.lower() in self.supported_extensions:
+                        files.append(file_path)
+
+        except Exception as e:
+            self.logger.error(f"Error traversing {repo_path}: {e}")
+
+        return files
+
+    def generate_file_tree(self, repo_path: Path, max_depth: int = 5) -> str:
+        """Generate file tree structure string for the repository"""
+        tree_lines = []
+
+        def add_to_tree(current_path: Path, prefix: str = "", depth: int = 0):
+            if depth > max_depth:
+                return
+
+            try:
+                items = sorted(
+                    current_path.iterdir(), key=lambda x: (x.is_file(), x.name.lower())
+                )
+                # Filter out irrelevant directories and files
+                items = [
+                    item
+                    for item in items
+                    if not item.name.startswith(".")
+                    and item.name not in self.skip_directories
+                ]
+
+                for i, item in enumerate(items):
+                    is_last = i == len(items) - 1
+                    current_prefix = "└── " if is_last else "├── "
+                    tree_lines.append(f"{prefix}{current_prefix}{item.name}")
+
+                    if item.is_dir():
+                        extension_prefix = "    " if is_last else "│   "
+                        add_to_tree(item, prefix + extension_prefix, depth + 1)
+                    elif item.suffix.lower() in self.supported_extensions:
+                        # Add file size information
+                        try:
+                            size = item.stat().st_size
+                            if size > 1024:
+                                size_str = f" ({size // 1024}KB)"
+                            else:
+                                size_str = f" ({size}B)"
+                            tree_lines[-1] += size_str
+                        except (OSError, PermissionError):
+                            pass
+
+            except PermissionError:
+                tree_lines.append(f"{prefix}├── [Permission Denied]")
+            except Exception as e:
+                tree_lines.append(f"{prefix}├── [Error: {str(e)}]")
+
+        tree_lines.append(f"{repo_path.name}/")
+        add_to_tree(repo_path)
+        return "\n".join(tree_lines)
+
+    async def pre_filter_files(self, repo_path: Path, file_tree: str) -> List[str]:
+        """Use LLM to pre-filter relevant files based on target structure"""
+        filter_prompt = f"""
+        You are a code analysis expert. Please analyze the following code repository file tree based on the target project structure and filter out files that may be relevant to the target project.
+
+        Target Project Structure:
+        {self.target_structure}
+
+        Code Repository File Tree:
+        {file_tree}
+
+        Please analyze which files might be helpful for implementing the target project structure, including:
+        - Core algorithm implementation files (such as GCN, recommendation systems, graph neural networks, etc.)
+        - Data processing and preprocessing files
+        - Loss functions and evaluation metric files
+        - Configuration and utility files
+        - Test files
+        - Documentation files
+
+        Please return the filtering results in JSON format:
+        {{
+            "relevant_files": [
+                {{
+                    "file_path": "file path relative to repository root",
+                    "relevance_reason": "why this file is relevant",
+                    "confidence": 0.0-1.0,
+                    "expected_contribution": "expected contribution to the target project"
+                }}
+            ],
+            "summary": {{
+                "total_files_analyzed": "total number of files analyzed",
+                "relevant_files_count": "number of relevant files",
+                "filtering_strategy": "explanation of filtering strategy"
+            }}
+        }}
+
+        Only return files with confidence > {self.min_confidence_score}. Focus on files related to recommendation systems, graph neural networks, and diffusion models.
+        """
+
+        try:
+            self.logger.info("Starting LLM pre-filtering of files...")
+            llm_response = await self._call_llm(
+                filter_prompt,
+                system_prompt="You are a professional code analysis and project architecture expert, skilled at identifying code file functionality and relevance.",
+                max_tokens=2000,
+            )
+
+            # Parse JSON response
+            match = re.search(r"\{.*\}", llm_response, re.DOTALL)
+            if not match:
+                self.logger.warning(
+                    "Unable to parse LLM filtering response, will use all files"
+                )
+                return []
+
+            filter_data = json.loads(match.group(0))
+            relevant_files = filter_data.get("relevant_files", [])
+
+            # Extract file paths
+            selected_files = []
+            for file_info in relevant_files:
+                file_path = file_info.get("file_path", "")
+                confidence = file_info.get("confidence", 0.0)
+                # Use configured minimum confidence threshold
+                if file_path and confidence > self.min_confidence_score:
+                    selected_files.append(file_path)
+
+            summary = filter_data.get("summary", {})
+            self.logger.info(
+                f"LLM filtering completed: {summary.get('relevant_files_count', len(selected_files))} relevant files selected"
+            )
+            self.logger.info(
+                f"Filtering strategy: {summary.get('filtering_strategy', 'Not provided')}"
+            )
+
+            return selected_files
+
+        except Exception as e:
+            self.logger.error(f"LLM pre-filtering failed: {e}")
+            self.logger.info("Will fallback to analyzing all files")
+            return []
+
+    def filter_files_by_paths(
+        self, all_files: List[Path], selected_paths: List[str], repo_path: Path
+    ) -> List[Path]:
+        """Filter file list based on LLM-selected paths"""
+        if not selected_paths:
+            return all_files
+
+        filtered_files = []
+
+        for file_path in all_files:
+            # Get path relative to repository root
+            relative_path = str(file_path.relative_to(repo_path))
+
+            # Check if it's in the selected list
+            for selected_path in selected_paths:
+                # Normalize path comparison
+                if (
+                    relative_path == selected_path
+                    or relative_path.replace("\\", "/")
+                    == selected_path.replace("\\", "/")
+                    or selected_path in relative_path
+                    or relative_path in selected_path
+                ):
+                    filtered_files.append(file_path)
+                    break
+
+        return filtered_files
+
+    def _get_cache_key(self, file_path: Path) -> str:
+        """Generate cache key for file content"""
+        try:
+            stats = file_path.stat()
+            return f"{file_path}:{stats.st_mtime}:{stats.st_size}"
+        except (OSError, PermissionError):
+            return str(file_path)
+
+    def _manage_cache_size(self):
+        """Manage cache size to stay within limits"""
+        if not self.enable_content_caching or not self.content_cache:
+            return
+
+        if len(self.content_cache) > self.max_cache_size:
+            # Remove oldest entries (simple FIFO strategy)
+            excess_count = len(self.content_cache) - self.max_cache_size + 10
+            keys_to_remove = list(self.content_cache.keys())[:excess_count]
+
+            for key in keys_to_remove:
+                del self.content_cache[key]
+
+            if self.verbose_output:
+                self.logger.info(
+                    f"Cache cleaned: removed {excess_count} entries, {len(self.content_cache)} entries remaining"
+                )
+
+    async def analyze_file_content(self, file_path: Path) -> FileSummary:
+        """Analyze a single file and create summary with caching support"""
+        try:
+            # Check file size before reading
+            file_size = file_path.stat().st_size
+            if file_size > self.max_file_size:
+                self.logger.warning(
+                    f"Skipping file {file_path} - size {file_size} bytes exceeds limit {self.max_file_size}"
+                )
+                return FileSummary(
+                    file_path=str(file_path.relative_to(self.code_base_path)),
+                    file_type="skipped - too large",
+                    main_functions=[],
+                    key_concepts=[],
+                    dependencies=[],
+                    summary=f"File skipped - size {file_size} bytes exceeds {self.max_file_size} byte limit",
+                    lines_of_code=0,
+                    last_modified=datetime.fromtimestamp(
+                        file_path.stat().st_mtime
+                    ).isoformat(),
+                )
+
+            # Check cache if enabled
+            cache_key = None
+            if self.enable_content_caching:
+                cache_key = self._get_cache_key(file_path)
+                if cache_key in self.content_cache:
+                    if self.verbose_output:
+                        self.logger.info(f"Using cached analysis for {file_path.name}")
+                    return self.content_cache[cache_key]
+
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+
+            # Get file stats
+            stats = file_path.stat()
+            lines_of_code = len([line for line in content.split("\n") if line.strip()])
+
+            # Truncate content based on config
+            content_for_analysis = content[: self.max_content_length]
+            content_suffix = "..." if len(content) > self.max_content_length else ""
+
+            # Create analysis prompt
+            analysis_prompt = f"""
+            Analyze this code file and provide a structured summary:
+
+            File: {file_path.name}
+            Content:
+            ```
+            {content_for_analysis}{content_suffix}
+            ```
+
+            Please provide analysis in this JSON format:
+            {{
+                "file_type": "description of what type of file this is",
+                "main_functions": ["list", "of", "main", "functions", "or", "classes"],
+                "key_concepts": ["important", "concepts", "algorithms", "patterns"],
+                "dependencies": ["external", "libraries", "or", "imports"],
+                "summary": "2-3 sentence summary of what this file does"
+            }}
+
+            Focus on the core functionality and potential reusability.
+            """
+
+            # Get LLM analysis with configured parameters
+            llm_response = await self._call_llm(analysis_prompt, max_tokens=1000)
+
+            try:
+                # Try to parse JSON response
+                match = re.search(r"\{.*\}", llm_response, re.DOTALL)
+                analysis_data = json.loads(match.group(0))
+            except json.JSONDecodeError:
+                # Fallback to basic analysis if JSON parsing fails
+                analysis_data = {
+                    "file_type": f"{file_path.suffix} file",
+                    "main_functions": [],
+                    "key_concepts": [],
+                    "dependencies": [],
+                    "summary": "File analysis failed - JSON parsing error",
+                }
+
+            file_summary = FileSummary(
+                file_path=str(file_path.relative_to(self.code_base_path)),
+                file_type=analysis_data.get("file_type", "unknown"),
+                main_functions=analysis_data.get("main_functions", []),
+                key_concepts=analysis_data.get("key_concepts", []),
+                dependencies=analysis_data.get("dependencies", []),
+                summary=analysis_data.get("summary", "No summary available"),
+                lines_of_code=lines_of_code,
+                last_modified=datetime.fromtimestamp(stats.st_mtime).isoformat(),
+            )
+
+            # Cache the result if caching is enabled
+            if self.enable_content_caching and cache_key:
+                self.content_cache[cache_key] = file_summary
+                self._manage_cache_size()
+
+            return file_summary
+
+        except Exception as e:
+            self.logger.error(f"Error analyzing file {file_path}: {e}")
+            return FileSummary(
+                file_path=str(file_path.relative_to(self.code_base_path)),
+                file_type="error",
+                main_functions=[],
+                key_concepts=[],
+                dependencies=[],
+                summary=f"Analysis failed: {str(e)}",
+                lines_of_code=0,
+                last_modified="",
+            )
+
+    async def find_relationships(
+        self, file_summary: FileSummary
+    ) -> List[FileRelationship]:
+        """Find relationships between a repo file and target structure"""
+
+        # Build relationship type description from config
+        relationship_type_desc = []
+        for rel_type, weight in self.relationship_types.items():
+            relationship_type_desc.append(f"- {rel_type} (priority: {weight})")
+
+        relationship_prompt = f"""
+        Analyze the relationship between this existing code file and the target project structure.
+
+        Existing File Analysis:
+        - Path: {file_summary.file_path}
+        - Type: {file_summary.file_type}
+        - Functions: {', '.join(file_summary.main_functions)}
+        - Concepts: {', '.join(file_summary.key_concepts)}
+        - Summary: {file_summary.summary}
+
+        Target Project Structure:
+        {self.target_structure}
+
+        Available relationship types (with priority weights):
+        {chr(10).join(relationship_type_desc)}
+
+        Identify potential relationships and provide analysis in this JSON format:
+        {{
+            "relationships": [
+                {{
+                    "target_file_path": "path/in/target/structure",
+                    "relationship_type": "direct_match|partial_match|reference|utility",
+                    "confidence_score": 0.0-1.0,
+                    "helpful_aspects": ["specific", "aspects", "that", "could", "help"],
+                    "potential_contributions": ["how", "this", "could", "contribute"],
+                    "usage_suggestions": "detailed suggestion on how to use this file"
+                }}
+            ]
+        }}
+
+        Consider the priority weights when determining relationship types. Higher weight types should be preferred when multiple types apply.
+        Only include relationships with confidence > {self.min_confidence_score}. Focus on concrete, actionable connections.
+        """
+
+        try:
+            llm_response = await self._call_llm(relationship_prompt, max_tokens=1500)
+
+            match = re.search(r"\{.*\}", llm_response, re.DOTALL)
+            relationship_data = json.loads(match.group(0))
+
+            relationships = []
+            for rel_data in relationship_data.get("relationships", []):
+                confidence_score = float(rel_data.get("confidence_score", 0.0))
+                relationship_type = rel_data.get("relationship_type", "reference")
+
+                # Validate relationship type is in config
+                if relationship_type not in self.relationship_types:
+                    if self.verbose_output:
+                        self.logger.warning(
+                            f"Unknown relationship type '{relationship_type}', using 'reference'"
+                        )
+                    relationship_type = "reference"
+
+                # Apply configured minimum confidence filter
+                if confidence_score > self.min_confidence_score:
+                    relationship = FileRelationship(
+                        repo_file_path=file_summary.file_path,
+                        target_file_path=rel_data.get("target_file_path", ""),
+                        relationship_type=relationship_type,
+                        confidence_score=confidence_score,
+                        helpful_aspects=rel_data.get("helpful_aspects", []),
+                        potential_contributions=rel_data.get(
+                            "potential_contributions", []
+                        ),
+                        usage_suggestions=rel_data.get("usage_suggestions", ""),
+                    )
+                    relationships.append(relationship)
+
+            return relationships
+
+        except Exception as e:
+            self.logger.error(
+                f"Error finding relationships for {file_summary.file_path}: {e}"
+            )
+            return []
+
+    async def _analyze_single_file_with_relationships(
+        self, file_path: Path, index: int, total: int
+    ) -> tuple:
+        """Analyze a single file and its relationships (for concurrent processing)"""
+        if self.verbose_output:
+            self.logger.info(f"Analyzing file {index}/{total}: {file_path.name}")
+
+        # Get file summary
+        file_summary = await self.analyze_file_content(file_path)
+
+        # Find relationships
+        relationships = await self.find_relationships(file_summary)
+
+        return file_summary, relationships
+
+    async def process_repository(self, repo_path: Path) -> RepoIndex:
+        """Process a single repository and create complete index with optional concurrent processing"""
+        repo_name = repo_path.name
+        self.logger.info(f"Processing repository: {repo_name}")
+
+        # Step 1: Generate file tree
+        self.logger.info("Generating file tree structure...")
+        file_tree = self.generate_file_tree(repo_path)
+
+        # Step 2: Get all files
+        all_files = self.get_all_repo_files(repo_path)
+        self.logger.info(f"Found {len(all_files)} files in {repo_name}")
+
+        # Step 3: LLM pre-filtering of relevant files
+        if self.enable_pre_filtering:
+            self.logger.info("Using LLM for file pre-filtering...")
+            selected_file_paths = await self.pre_filter_files(repo_path, file_tree)
+        else:
+            self.logger.info("Pre-filtering is disabled, will analyze all files")
+            selected_file_paths = []
+
+        # Step 4: Filter file list based on filtering results
+        if selected_file_paths:
+            files_to_analyze = self.filter_files_by_paths(
+                all_files, selected_file_paths, repo_path
+            )
+            self.logger.info(
+                f"After LLM filtering, will analyze {len(files_to_analyze)} relevant files (from {len(all_files)} total)"
+            )
+        else:
+            files_to_analyze = all_files
+            self.logger.info("LLM filtering failed, will analyze all files")
+
+        # Step 5: Analyze filtered files (concurrent or sequential)
+        if self.enable_concurrent_analysis and len(files_to_analyze) > 1:
+            self.logger.info(
+                f"Using concurrent analysis with max {self.max_concurrent_files} parallel files"
+            )
+            file_summaries, all_relationships = await self._process_files_concurrently(
+                files_to_analyze
+            )
+        else:
+            self.logger.info("Using sequential file analysis")
+            file_summaries, all_relationships = await self._process_files_sequentially(
+                files_to_analyze
+            )
+
+        # Step 6: Create repository index
+        repo_index = RepoIndex(
+            repo_name=repo_name,
+            total_files=len(all_files),  # Record original file count
+            file_summaries=file_summaries,
+            relationships=all_relationships,
+            analysis_metadata={
+                "analysis_date": datetime.now().isoformat(),
+                "target_structure_analyzed": self.target_structure[:200] + "...",
+                "total_relationships_found": len(all_relationships),
+                "high_confidence_relationships": len(
+                    [
+                        r
+                        for r in all_relationships
+                        if r.confidence_score > self.high_confidence_threshold
+                    ]
+                ),
+                "analyzer_version": "1.4.0",  # Updated version to reflect augmented LLM support
+                "pre_filtering_enabled": self.enable_pre_filtering,
+                "files_before_filtering": len(all_files),
+                "files_after_filtering": len(files_to_analyze),
+                "filtering_efficiency": round(
+                    (1 - len(files_to_analyze) / len(all_files)) * 100, 2
+                )
+                if all_files
+                else 0,
+                "config_file_used": self.indexer_config_path,
+                "min_confidence_score": self.min_confidence_score,
+                "high_confidence_threshold": self.high_confidence_threshold,
+                "concurrent_analysis_used": self.enable_concurrent_analysis,
+                "content_caching_enabled": self.enable_content_caching,
+                "cache_hits": len(self.content_cache) if self.content_cache else 0,
+            },
+        )
+
+        return repo_index
+
+    async def _process_files_sequentially(self, files_to_analyze: list) -> tuple:
+        """Process files sequentially (original method)"""
+        file_summaries = []
+        all_relationships = []
+
+        for i, file_path in enumerate(files_to_analyze, 1):
+            (
+                file_summary,
+                relationships,
+            ) = await self._analyze_single_file_with_relationships(
+                file_path, i, len(files_to_analyze)
+            )
+            file_summaries.append(file_summary)
+            all_relationships.extend(relationships)
+
+            # Add configured delay to avoid overwhelming the LLM API
+            await asyncio.sleep(self.request_delay)
+
+        return file_summaries, all_relationships
+
+    async def _process_files_concurrently(self, files_to_analyze: list) -> tuple:
+        """Process files concurrently with semaphore limiting"""
+        file_summaries = []
+        all_relationships = []
+
+        # Create semaphore to limit concurrent tasks
+        semaphore = asyncio.Semaphore(self.max_concurrent_files)
+        tasks = []
+
+        async def _process_with_semaphore(file_path: Path, index: int, total: int):
+            async with semaphore:
+                # Add a small delay to space out concurrent requests
+                if index > 1:
+                    await asyncio.sleep(
+                        self.request_delay * 0.5
+                    )  # Reduced delay for concurrent processing
+                return await self._analyze_single_file_with_relationships(
+                    file_path, index, total
+                )
+
+        try:
+            # Create tasks for all files
+            tasks = [
+                _process_with_semaphore(file_path, i, len(files_to_analyze))
+                for i, file_path in enumerate(files_to_analyze, 1)
+            ]
+
+            # Process tasks and collect results
+            if self.verbose_output:
+                self.logger.info(
+                    f"Starting concurrent analysis of {len(tasks)} files..."
+                )
+
+            try:
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+
+                for i, result in enumerate(results):
+                    if isinstance(result, Exception):
+                        self.logger.error(
+                            f"Failed to analyze file {files_to_analyze[i]}: {result}"
+                        )
+                        # Create error summary
+                        error_summary = FileSummary(
+                            file_path=str(
+                                files_to_analyze[i].relative_to(self.code_base_path)
+                            ),
+                            file_type="error",
+                            main_functions=[],
+                            key_concepts=[],
+                            dependencies=[],
+                            summary=f"Concurrent analysis failed: {str(result)}",
+                            lines_of_code=0,
+                            last_modified="",
+                        )
+                        file_summaries.append(error_summary)
+                    else:
+                        file_summary, relationships = result
+                        file_summaries.append(file_summary)
+                        all_relationships.extend(relationships)
+
+            except Exception as e:
+                self.logger.error(f"Concurrent processing failed: {e}")
+                # Cancel any remaining tasks
+                for task in tasks:
+                    if not task.done() and not task.cancelled():
+                        task.cancel()
+
+                # Wait for cancelled tasks to complete
+                try:
+                    await asyncio.sleep(0.1)  # Brief wait for cancellation
+                except Exception:
+                    pass
+
+                # Fallback to sequential processing
+                self.logger.info("Falling back to sequential processing...")
+                return await self._process_files_sequentially(files_to_analyze)
+
+            if self.verbose_output:
+                self.logger.info(
+                    f"Concurrent analysis completed: {len(file_summaries)} files processed"
+                )
+
+            return file_summaries, all_relationships
+
+        except Exception as e:
+            # Ensure all tasks are cancelled in case of unexpected errors
+            if tasks:
+                for task in tasks:
+                    if not task.done() and not task.cancelled():
+                        task.cancel()
+
+            # Wait briefly for cancellation to complete
+            try:
+                await asyncio.sleep(0.1)
+            except Exception:
+                pass
+
+            self.logger.error(f"Critical error in concurrent processing: {e}")
+            # Fallback to sequential processing
+            self.logger.info(
+                "Falling back to sequential processing due to critical error..."
+            )
+            return await self._process_files_sequentially(files_to_analyze)
+
+        finally:
+            # Final cleanup: ensure all tasks are properly finished
+            if tasks:
+                for task in tasks:
+                    if not task.done() and not task.cancelled():
+                        task.cancel()
+
+            # Clear task references to help with garbage collection
+            tasks.clear()
+
+            # Force garbage collection to help clean up semaphore and related resources
+            import gc
+
+            gc.collect()
+
+    async def build_all_indexes(self) -> Dict[str, str]:
+        """Build indexes for all repositories in code_base"""
+        if not self.code_base_path.exists():
+            raise FileNotFoundError(
+                f"Code base path does not exist: {self.code_base_path}"
+            )
+
+        # Get all repository directories
+        repo_dirs = [
+            d
+            for d in self.code_base_path.iterdir()
+            if d.is_dir() and not d.name.startswith(".")
+        ]
+
+        if not repo_dirs:
+            raise ValueError(f"No repositories found in {self.code_base_path}")
+
+        self.logger.info(f"Found {len(repo_dirs)} repositories to process")
+
+        # Process each repository
+        output_files = {}
+        statistics_data = []
+
+        for repo_dir in repo_dirs:
+            try:
+                # Process repository
+                repo_index = await self.process_repository(repo_dir)
+
+                # Generate output filename using configured pattern
+                output_filename = self.index_filename_pattern.format(
+                    repo_name=repo_index.repo_name
+                )
+                output_file = self.output_dir / output_filename
+
+                # Get output configuration
+                output_config = self.indexer_config.get("output", {})
+                json_indent = output_config.get("json_indent", 2)
+                ensure_ascii = not output_config.get("ensure_ascii", False)
+
+                # Save to JSON file
+                with open(output_file, "w", encoding="utf-8") as f:
+                    if self.include_metadata:
+                        json.dump(
+                            asdict(repo_index),
+                            f,
+                            indent=json_indent,
+                            ensure_ascii=ensure_ascii,
+                        )
+                    else:
+                        # Save without metadata if disabled
+                        index_data = asdict(repo_index)
+                        index_data.pop("analysis_metadata", None)
+                        json.dump(
+                            index_data, f, indent=json_indent, ensure_ascii=ensure_ascii
+                        )
+
+                output_files[repo_index.repo_name] = str(output_file)
+                self.logger.info(
+                    f"Saved index for {repo_index.repo_name} to {output_file}"
+                )
+
+                # Collect statistics for report
+                if self.generate_statistics:
+                    stats = self._extract_repository_statistics(repo_index)
+                    statistics_data.append(stats)
+
+            except Exception as e:
+                self.logger.error(f"Failed to process repository {repo_dir.name}: {e}")
+                continue
+
+        # Generate additional reports if configured
+        if self.generate_summary:
+            summary_path = self.generate_summary_report(output_files)
+            self.logger.info(f"Generated summary report: {summary_path}")
+
+        if self.generate_statistics:
+            stats_path = self.generate_statistics_report(statistics_data)
+            self.logger.info(f"Generated statistics report: {stats_path}")
+
+        return output_files
+
+    def _extract_repository_statistics(self, repo_index: RepoIndex) -> Dict[str, Any]:
+        """Extract statistical information from a repository index"""
+        metadata = repo_index.analysis_metadata
+
+        # Count relationship types
+        relationship_type_counts = {}
+        for rel in repo_index.relationships:
+            rel_type = rel.relationship_type
+            relationship_type_counts[rel_type] = (
+                relationship_type_counts.get(rel_type, 0) + 1
+            )
+
+        # Count file types
+        file_type_counts = {}
+        for file_summary in repo_index.file_summaries:
+            file_type = file_summary.file_type
+            file_type_counts[file_type] = file_type_counts.get(file_type, 0) + 1
+
+        # Calculate statistics
+        total_lines = sum(fs.lines_of_code for fs in repo_index.file_summaries)
+        avg_lines = (
+            total_lines / len(repo_index.file_summaries)
+            if repo_index.file_summaries
+            else 0
+        )
+
+        avg_confidence = (
+            sum(r.confidence_score for r in repo_index.relationships)
+            / len(repo_index.relationships)
+            if repo_index.relationships
+            else 0
+        )
+
+        return {
+            "repo_name": repo_index.repo_name,
+            "total_files": repo_index.total_files,
+            "analyzed_files": len(repo_index.file_summaries),
+            "total_relationships": len(repo_index.relationships),
+            "high_confidence_relationships": metadata.get(
+                "high_confidence_relationships", 0
+            ),
+            "relationship_type_counts": relationship_type_counts,
+            "file_type_counts": file_type_counts,
+            "total_lines_of_code": total_lines,
+            "average_lines_per_file": round(avg_lines, 2),
+            "average_confidence_score": round(avg_confidence, 3),
+            "filtering_efficiency": metadata.get("filtering_efficiency", 0),
+            "concurrent_analysis_used": metadata.get("concurrent_analysis_used", False),
+            "cache_hits": metadata.get("cache_hits", 0),
+            "analysis_date": metadata.get("analysis_date", "unknown"),
+        }
+
+    def generate_statistics_report(self, statistics_data: List[Dict[str, Any]]) -> str:
+        """Generate a detailed statistics report"""
+        stats_path = self.output_dir / self.stats_filename
+
+        # Calculate aggregate statistics
+        total_repos = len(statistics_data)
+        total_files_analyzed = sum(stat["analyzed_files"] for stat in statistics_data)
+        total_relationships = sum(
+            stat["total_relationships"] for stat in statistics_data
+        )
+        total_lines = sum(stat["total_lines_of_code"] for stat in statistics_data)
+
+        # Aggregate relationship types
+        aggregated_rel_types = {}
+        for stat in statistics_data:
+            for rel_type, count in stat["relationship_type_counts"].items():
+                aggregated_rel_types[rel_type] = (
+                    aggregated_rel_types.get(rel_type, 0) + count
+                )
+
+        # Aggregate file types
+        aggregated_file_types = {}
+        for stat in statistics_data:
+            for file_type, count in stat["file_type_counts"].items():
+                aggregated_file_types[file_type] = (
+                    aggregated_file_types.get(file_type, 0) + count
+                )
+
+        # Calculate averages
+        avg_files_per_repo = total_files_analyzed / total_repos if total_repos else 0
+        avg_relationships_per_repo = (
+            total_relationships / total_repos if total_repos else 0
+        )
+        avg_lines_per_repo = total_lines / total_repos if total_repos else 0
+
+        # Build statistics report
+        statistics_report = {
+            "report_generation_time": datetime.now().isoformat(),
+            "analyzer_version": "1.4.0",
+            "configuration_used": {
+                "config_file": self.indexer_config_path,
+                "concurrent_analysis_enabled": self.enable_concurrent_analysis,
+                "content_caching_enabled": self.enable_content_caching,
+                "pre_filtering_enabled": self.enable_pre_filtering,
+                "min_confidence_score": self.min_confidence_score,
+                "high_confidence_threshold": self.high_confidence_threshold,
+            },
+            "aggregate_statistics": {
+                "total_repositories_processed": total_repos,
+                "total_files_analyzed": total_files_analyzed,
+                "total_relationships_found": total_relationships,
+                "total_lines_of_code": total_lines,
+                "average_files_per_repository": round(avg_files_per_repo, 2),
+                "average_relationships_per_repository": round(
+                    avg_relationships_per_repo, 2
+                ),
+                "average_lines_per_repository": round(avg_lines_per_repo, 2),
+            },
+            "relationship_type_distribution": aggregated_rel_types,
+            "file_type_distribution": aggregated_file_types,
+            "repository_details": statistics_data,
+            "performance_metrics": {
+                "concurrent_processing_repos": sum(
+                    1
+                    for s in statistics_data
+                    if s.get("concurrent_analysis_used", False)
+                ),
+                "cache_efficiency": {
+                    "total_cache_hits": sum(
+                        s.get("cache_hits", 0) for s in statistics_data
+                    ),
+                    "repositories_with_caching": sum(
+                        1 for s in statistics_data if s.get("cache_hits", 0) > 0
+                    ),
+                },
+                "filtering_efficiency": {
+                    "average_filtering_efficiency": round(
+                        sum(s.get("filtering_efficiency", 0) for s in statistics_data)
+                        / total_repos,
+                        2,
+                    )
+                    if total_repos
+                    else 0,
+                    "max_filtering_efficiency": max(
+                        (s.get("filtering_efficiency", 0) for s in statistics_data),
+                        default=0,
+                    ),
+                    "min_filtering_efficiency": min(
+                        (s.get("filtering_efficiency", 0) for s in statistics_data),
+                        default=0,
+                    ),
+                },
+            },
+        }
+
+        # Get output configuration
+        output_config = self.indexer_config.get("output", {})
+        json_indent = output_config.get("json_indent", 2)
+        ensure_ascii = not output_config.get("ensure_ascii", False)
+
+        with open(stats_path, "w", encoding="utf-8") as f:
+            json.dump(
+                statistics_report, f, indent=json_indent, ensure_ascii=ensure_ascii
+            )
+
+        return str(stats_path)
+
+    def generate_summary_report(self, output_files: Dict[str, str]) -> str:
+        """Generate a summary report of all indexes created"""
+        report_path = self.output_dir / "indexing_summary.json"
+
+        # Get output configuration from config file
+        output_config = self.indexer_config.get("output", {})
+        json_indent = output_config.get("json_indent", 2)
+        ensure_ascii = not output_config.get("ensure_ascii", False)
+
+        summary_data = {
+            "indexing_completion_time": datetime.now().isoformat(),
+            "total_repositories_processed": len(output_files),
+            "output_files": output_files,
+            "target_structure": self.target_structure,
+            "code_base_path": str(self.code_base_path),
+            "configuration": {
+                "config_file_used": self.indexer_config_path,
+                "api_config_file": self.config_path,
+                "pre_filtering_enabled": self.enable_pre_filtering,
+                "min_confidence_score": self.min_confidence_score,
+                "high_confidence_threshold": self.high_confidence_threshold,
+                "max_file_size": self.max_file_size,
+                "max_content_length": self.max_content_length,
+                "request_delay": self.request_delay,
+                "supported_extensions_count": len(self.supported_extensions),
+                "skip_directories_count": len(self.skip_directories),
+            },
+        }
+
+        with open(report_path, "w", encoding="utf-8") as f:
+            json.dump(summary_data, f, indent=json_indent, ensure_ascii=ensure_ascii)
+
+        return str(report_path)
+
+
+async def main():
+    """Main function to run the code indexer with full configuration support"""
+
+    # Configuration - can be overridden by config file
+    config_file = "DeepCode/tools/indexer_config.yaml"
+    api_config_file = "DeepCode/mcp_agent.secrets.yaml"
+
+    # You can override these parameters or let them be read from config
+    code_base_path = "DeepCode/deepcode_lab/papers/1/code_base/"  # Will use config file value if None
+    output_dir = (
+        "DeepCode/deepcode_lab/papers/1/indexes/"  # Will use config file value if None
+    )
+
+    # Target structure - this should be customized for your specific project
+    target_structure = """
+    project/
+    ├── src/
+    │   ├── core/
+    │   │   ├── gcn.py        # GCN encoder
+    │   │   ├── diffusion.py  # forward/reverse processes
+    │   │   ├── denoiser.py   # denoising MLP
+    │   │   └── fusion.py     # fusion combiner
+    │   ├── models/           # model wrapper classes
+    │   │   └── recdiff.py
+    │   ├── utils/
+    │   │   ├── data.py       # loading & preprocessing
+    │   │   ├── predictor.py  # scoring functions
+    │   │   ├── loss.py       # loss functions
+    │   │   ├── metrics.py    # NDCG, Recall etc.
+    │   │   └── sched.py      # beta/alpha schedule utils
+    │   └── configs/
+    │       └── default.yaml  # hyperparameters, paths
+    ├── tests/
+    │   ├── test_gcn.py
+    │   ├── test_diffusion.py
+    │   ├── test_denoiser.py
+    │   ├── test_loss.py
+    │   └── test_pipeline.py
+    ├── docs/
+    │   ├── architecture.md
+    │   ├── api_reference.md
+    │   └── README.md
+    ├── experiments/
+    │   ├── run_experiment.py
+    │   └── notebooks/
+    │       └── analysis.ipynb
+    ├── requirements.txt
+    └── setup.py
+    """
+
+    print("🚀 Starting Code Indexer with Enhanced Configuration Support")
+    print(f"📋 Configuration file: {config_file}")
+    print(f"🔑 API configuration file: {api_config_file}")
+
+    # Create indexer with full configuration support
+    try:
+        indexer = CodeIndexer(
+            code_base_path=code_base_path,  # None = read from config
+            target_structure=target_structure,  # Required - project specific
+            output_dir=output_dir,  # None = read from config
+            config_path=api_config_file,  # API configuration file
+            indexer_config_path=config_file,  # Configuration file
+            enable_pre_filtering=True,  # Can be overridden in config
+        )
+
+        # Display configuration information
+        print(f"📁 Code base path: {indexer.code_base_path}")
+        print(f"📂 Output directory: {indexer.output_dir}")
+        print(
+            f"🤖 Default models: Anthropic={indexer.default_models['anthropic']}, OpenAI={indexer.default_models['openai']}"
+        )
+        print(f"🔧 Preferred LLM: {get_preferred_llm_class(api_config_file).__name__}")
+        print(
+            f"⚡ Concurrent analysis: {'enabled' if indexer.enable_concurrent_analysis else 'disabled'}"
+        )
+        print(
+            f"🗄️  Content caching: {'enabled' if indexer.enable_content_caching else 'disabled'}"
+        )
+        print(
+            f"🔍 Pre-filtering: {'enabled' if indexer.enable_pre_filtering else 'disabled'}"
+        )
+        print(f"🐛 Debug mode: {'enabled' if indexer.verbose_output else 'disabled'}")
+        print(
+            f"🎭 Mock responses: {'enabled' if indexer.mock_llm_responses else 'disabled'}"
+        )
+
+        # Validate configuration
+        if not indexer.code_base_path.exists():
+            raise FileNotFoundError(
+                f"Code base path does not exist: {indexer.code_base_path}"
+            )
+
+        if not target_structure:
+            raise ValueError("Target structure is required for analysis")
+
+        print("\n🔧 Starting indexing process...")
+
+        # Build all indexes
+        output_files = await indexer.build_all_indexes()
+
+        # Display results
+        print("\n✅ Indexing completed successfully!")
+        print(f"📊 Processed {len(output_files)} repositories")
+        print("📁 Output files:")
+        for repo_name, file_path in output_files.items():
+            print(f"   - {repo_name}: {file_path}")
+
+        # Display additional reports generated
+        if indexer.generate_summary:
+            summary_file = indexer.output_dir / indexer.summary_filename
+            if summary_file.exists():
+                print(f"📋 Summary report: {summary_file}")
+
+        if indexer.generate_statistics:
+            stats_file = indexer.output_dir / indexer.stats_filename
+            if stats_file.exists():
+                print(f"📈 Statistics report: {stats_file}")
+
+        # Performance information
+        if indexer.enable_content_caching and indexer.content_cache:
+            print(f"🗄️  Cache performance: {len(indexer.content_cache)} items cached")
+
+        print("\n🎉 Code indexing process completed successfully!")
+
+    except FileNotFoundError as e:
+        print(f"❌ File not found error: {e}")
+        print("💡 Please check your configuration file paths")
+    except ValueError as e:
+        print(f"❌ Configuration error: {e}")
+        print("💡 Please check your configuration file settings")
+    except Exception as e:
+        print(f"❌ Indexing failed: {e}")
+        print("💡 Check the logs for more details")
+
+        # Print debug information if available
+        try:
+            indexer
+            if indexer.verbose_output:
+                import traceback
+
+                print("\n🐛 Debug information:")
+                traceback.print_exc()
+        except NameError:
+            pass
+
+
+def print_usage_example():
+    """Print usage examples for different scenarios"""
+    print("""
+    📖 Code Indexer Usage Examples:
+
+    1. Basic usage with config file:
+       - Update paths in indexer_config.yaml
+       - Run: python code_indexer.py
+
+    2. Enable debugging:
+       - Set debug.verbose_output: true in config
+       - Set debug.save_raw_responses: true to save LLM responses
+
+    3. Enable concurrent processing:
+       - Set performance.enable_concurrent_analysis: true
+       - Adjust performance.max_concurrent_files as needed
+
+    4. Enable caching:
+       - Set performance.enable_content_caching: true
+       - Adjust performance.max_cache_size as needed
+
+    5. Mock mode for testing:
+       - Set debug.mock_llm_responses: true
+       - No API calls will be made
+
+    6. Custom output:
+       - Modify output.index_filename_pattern
+       - Set output.generate_statistics: true for detailed reports
+
+    📋 Configuration file location: tools/indexer_config.yaml
+    """)
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1 and sys.argv[1] in ["--help", "-h", "help"]:
+        print_usage_example()
+    else:
+        asyncio.run(main())

projects/ui/DeepCode/tools/code_reference_indexer.py

@@ -0,0 +1,495 @@
+#!/usr/bin/env python3
+"""
+Code Reference Indexer MCP Tool - Unified Version
+
+Specialized MCP tool for searching relevant index content in indexes folder
+and formatting it for LLM code implementation reference.
+
+Core Features:
+1. **UNIFIED TOOL**: Combined search_code_references that handles directory setup, loading, and searching in one call
+2. Match relevant reference code based on target file path and functionality requirements
+3. Format output of relevant code examples, functions and concepts
+4. Provide structured reference information for LLM use
+
+Key Improvement:
+- Single tool call that handles all steps internally
+- Agent only needs to provide indexes_path and target_file
+- No dependency on calling order or global state management
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Tuple
+from dataclasses import dataclass
+import logging
+
+# Import MCP modules
+from mcp.server.fastmcp import FastMCP
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create FastMCP server instance
+mcp = FastMCP("code-reference-indexer")
+
+
+@dataclass
+class CodeReference:
+    """Code reference information structure"""
+
+    file_path: str
+    file_type: str
+    main_functions: List[str]
+    key_concepts: List[str]
+    dependencies: List[str]
+    summary: str
+    lines_of_code: int
+    repo_name: str
+    confidence_score: float = 0.0
+
+
+@dataclass
+class RelationshipInfo:
+    """Relationship information structure"""
+
+    repo_file_path: str
+    target_file_path: str
+    relationship_type: str
+    confidence_score: float
+    helpful_aspects: List[str]
+    potential_contributions: List[str]
+    usage_suggestions: str
+
+
+def load_index_files_from_directory(indexes_directory: str) -> Dict[str, Dict]:
+    """Load all index files from specified directory"""
+    indexes_path = Path(indexes_directory).resolve()
+
+    if not indexes_path.exists():
+        logger.warning(f"Indexes directory does not exist: {indexes_path}")
+        return {}
+
+    index_cache = {}
+
+    for index_file in indexes_path.glob("*.json"):
+        try:
+            with open(index_file, "r", encoding="utf-8") as f:
+                index_data = json.load(f)
+                index_cache[index_file.stem] = index_data
+                logger.info(f"Loaded index file: {index_file.name}")
+        except Exception as e:
+            logger.error(f"Failed to load index file {index_file.name}: {e}")
+
+    logger.info(f"Loaded {len(index_cache)} index files from {indexes_path}")
+    return index_cache
+
+
+def extract_code_references(index_data: Dict) -> List[CodeReference]:
+    """Extract code reference information from index data"""
+    references = []
+
+    repo_name = index_data.get("repo_name", "Unknown")
+    file_summaries = index_data.get("file_summaries", [])
+
+    for file_summary in file_summaries:
+        reference = CodeReference(
+            file_path=file_summary.get("file_path", ""),
+            file_type=file_summary.get("file_type", ""),
+            main_functions=file_summary.get("main_functions", []),
+            key_concepts=file_summary.get("key_concepts", []),
+            dependencies=file_summary.get("dependencies", []),
+            summary=file_summary.get("summary", ""),
+            lines_of_code=file_summary.get("lines_of_code", 0),
+            repo_name=repo_name,
+        )
+        references.append(reference)
+
+    return references
+
+
+def extract_relationships(index_data: Dict) -> List[RelationshipInfo]:
+    """Extract relationship information from index data"""
+    relationships = []
+
+    relationship_list = index_data.get("relationships", [])
+
+    for rel in relationship_list:
+        relationship = RelationshipInfo(
+            repo_file_path=rel.get("repo_file_path", ""),
+            target_file_path=rel.get("target_file_path", ""),
+            relationship_type=rel.get("relationship_type", ""),
+            confidence_score=rel.get("confidence_score", 0.0),
+            helpful_aspects=rel.get("helpful_aspects", []),
+            potential_contributions=rel.get("potential_contributions", []),
+            usage_suggestions=rel.get("usage_suggestions", ""),
+        )
+        relationships.append(relationship)
+
+    return relationships
+
+
+def calculate_relevance_score(
+    target_file: str, reference: CodeReference, keywords: List[str] = None
+) -> float:
+    """Calculate relevance score between reference code and target file"""
+    score = 0.0
+
+    # File name similarity
+    target_name = Path(target_file).stem.lower()
+    ref_name = Path(reference.file_path).stem.lower()
+
+    if target_name in ref_name or ref_name in target_name:
+        score += 0.3
+
+    # File type matching
+    target_extension = Path(target_file).suffix
+    ref_extension = Path(reference.file_path).suffix
+
+    if target_extension == ref_extension:
+        score += 0.2
+
+    # Keyword matching
+    if keywords:
+        keyword_matches = 0
+        total_searchable_text = (
+            " ".join(reference.key_concepts)
+            + " "
+            + " ".join(reference.main_functions)
+            + " "
+            + reference.summary
+            + " "
+            + reference.file_type
+        ).lower()
+
+        for keyword in keywords:
+            if keyword.lower() in total_searchable_text:
+                keyword_matches += 1
+
+        if keywords:
+            score += (keyword_matches / len(keywords)) * 0.5
+
+    return min(score, 1.0)
+
+
+def find_relevant_references_in_cache(
+    target_file: str,
+    index_cache: Dict[str, Dict],
+    keywords: List[str] = None,
+    max_results: int = 10,
+) -> List[Tuple[CodeReference, float]]:
+    """Find reference code relevant to target file from provided cache"""
+    all_references = []
+
+    # Collect reference information from all index files
+    for repo_name, index_data in index_cache.items():
+        references = extract_code_references(index_data)
+        for ref in references:
+            relevance_score = calculate_relevance_score(target_file, ref, keywords)
+            if relevance_score > 0.1:  # Only keep results with certain relevance
+                all_references.append((ref, relevance_score))
+
+    # Sort by relevance score
+    all_references.sort(key=lambda x: x[1], reverse=True)
+
+    return all_references[:max_results]
+
+
+def find_direct_relationships_in_cache(
+    target_file: str, index_cache: Dict[str, Dict]
+) -> List[RelationshipInfo]:
+    """Find direct relationships with target file from provided cache"""
+    relationships = []
+
+    # Normalize target file path (remove common prefixes if exists)
+    common_prefixes = ["src/", "core/", "lib/", "main/", "./"]
+    normalized_target = target_file.strip("/")
+    for prefix in common_prefixes:
+        if normalized_target.startswith(prefix):
+            normalized_target = normalized_target[len(prefix) :]
+            break
+
+    # Collect relationship information from all index files
+    for repo_name, index_data in index_cache.items():
+        repo_relationships = extract_relationships(index_data)
+        for rel in repo_relationships:
+            # Normalize target file path in relationship
+            normalized_rel_target = rel.target_file_path.strip("/")
+            for prefix in common_prefixes:
+                if normalized_rel_target.startswith(prefix):
+                    normalized_rel_target = normalized_rel_target[len(prefix) :]
+                    break
+
+            # Check target file path matching (support multiple matching methods)
+            if (
+                normalized_target == normalized_rel_target
+                or normalized_target in normalized_rel_target
+                or normalized_rel_target in normalized_target
+                or target_file in rel.target_file_path
+                or rel.target_file_path in target_file
+            ):
+                relationships.append(rel)
+
+    # Sort by confidence score
+    relationships.sort(key=lambda x: x.confidence_score, reverse=True)
+
+    return relationships
+
+
+def format_reference_output(
+    target_file: str,
+    relevant_refs: List[Tuple[CodeReference, float]],
+    relationships: List[RelationshipInfo],
+) -> str:
+    """Format reference information output"""
+    output_lines = []
+
+    output_lines.append(f"# Code Reference Information - {target_file}")
+    output_lines.append("=" * 80)
+    output_lines.append("")
+
+    # Direct relationship information
+    if relationships:
+        output_lines.append("## 🎯 Direct Relationships")
+        output_lines.append("")
+
+        for i, rel in enumerate(relationships[:5], 1):
+            output_lines.append(f"### {i}. {rel.repo_file_path}")
+            output_lines.append(f"**Relationship Type**: {rel.relationship_type}")
+            output_lines.append(f"**Confidence Score**: {rel.confidence_score:.2f}")
+            output_lines.append(
+                f"**Helpful Aspects**: {', '.join(rel.helpful_aspects)}"
+            )
+            output_lines.append(
+                f"**Potential Contributions**: {', '.join(rel.potential_contributions)}"
+            )
+            output_lines.append(f"**Usage Suggestions**: {rel.usage_suggestions}")
+            output_lines.append("")
+
+    # Relevant code references
+    if relevant_refs:
+        output_lines.append("## 📚 Relevant Code References")
+        output_lines.append("")
+
+        for i, (ref, score) in enumerate(relevant_refs[:8], 1):
+            output_lines.append(f"### {i}. {ref.file_path} (Relevance: {score:.2f})")
+            output_lines.append(f"**Repository**: {ref.repo_name}")
+            output_lines.append(f"**File Type**: {ref.file_type}")
+            output_lines.append(
+                f"**Main Functions**: {', '.join(ref.main_functions[:5])}"
+            )
+            output_lines.append(f"**Key Concepts**: {', '.join(ref.key_concepts[:8])}")
+            output_lines.append(f"**Dependencies**: {', '.join(ref.dependencies[:6])}")
+            output_lines.append(f"**Lines of Code**: {ref.lines_of_code}")
+            output_lines.append(f"**Summary**: {ref.summary[:300]}...")
+            output_lines.append("")
+
+    # Implementation suggestions
+    output_lines.append("## 💡 Implementation Suggestions")
+    output_lines.append("")
+
+    if relevant_refs:
+        # Collect all function names and concepts
+        all_functions = set()
+        all_concepts = set()
+        all_dependencies = set()
+
+        for ref, _ in relevant_refs[:5]:
+            all_functions.update(ref.main_functions)
+            all_concepts.update(ref.key_concepts)
+            all_dependencies.update(ref.dependencies)
+
+        output_lines.append("**Reference Function Name Patterns**:")
+        for func in sorted(list(all_functions))[:10]:
+            output_lines.append(f"- {func}")
+        output_lines.append("")
+
+        output_lines.append("**Important Concepts and Patterns**:")
+        for concept in sorted(list(all_concepts))[:15]:
+            output_lines.append(f"- {concept}")
+        output_lines.append("")
+
+        output_lines.append("**Potential Dependencies Needed**:")
+        for dep in sorted(list(all_dependencies))[:10]:
+            output_lines.append(f"- {dep}")
+        output_lines.append("")
+
+    output_lines.append("## 🚀 Next Actions")
+    output_lines.append(
+        "1. Analyze design patterns and architectural styles from the above reference code"
+    )
+    output_lines.append("2. Determine core functionalities and interfaces to implement")
+    output_lines.append("3. Choose appropriate dependency libraries and tools")
+    output_lines.append(
+        "4. Design implementation solution consistent with existing code style"
+    )
+    output_lines.append("5. Start writing specific code implementation")
+
+    return "\n".join(output_lines)
+
+
+# ==================== MCP Tool Definitions ====================
+
+
+@mcp.tool()
+async def search_code_references(
+    indexes_path: str, target_file: str, keywords: str = "", max_results: int = 10
+) -> str:
+    """
+    **UNIFIED TOOL**: Search relevant reference code from index files for target file implementation.
+    This tool combines directory setup, index loading, and searching in a single call.
+
+    Args:
+        indexes_path: Path to the indexes directory containing JSON index files
+        target_file: Target file path (file to be implemented)
+        keywords: Search keywords, comma-separated
+        max_results: Maximum number of results to return
+
+    Returns:
+        Formatted reference code information JSON string
+    """
+    try:
+        # Step 1: Load index files from specified directory
+        logger.info(f"Loading index files from: {indexes_path}")
+        index_cache = load_index_files_from_directory(indexes_path)
+
+        if not index_cache:
+            result = {
+                "status": "error",
+                "message": f"No index files found or failed to load from: {indexes_path}",
+                "target_file": target_file,
+                "indexes_path": indexes_path,
+            }
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        # Step 2: Parse keywords
+        keyword_list = (
+            [kw.strip() for kw in keywords.split(",") if kw.strip()] if keywords else []
+        )
+
+        # Step 3: Find relevant reference code
+        relevant_refs = find_relevant_references_in_cache(
+            target_file, index_cache, keyword_list, max_results
+        )
+
+        # Step 4: Find direct relationships
+        relationships = find_direct_relationships_in_cache(target_file, index_cache)
+
+        # Step 5: Format output
+        formatted_output = format_reference_output(
+            target_file, relevant_refs, relationships
+        )
+
+        result = {
+            "status": "success",
+            "target_file": target_file,
+            "indexes_path": indexes_path,
+            "keywords_used": keyword_list,
+            "total_references_found": len(relevant_refs),
+            "total_relationships_found": len(relationships),
+            "formatted_content": formatted_output,
+            "indexes_loaded": list(index_cache.keys()),
+            "total_indexes_loaded": len(index_cache),
+        }
+
+        logger.info(
+            f"Successfully found {len(relevant_refs)} references and {len(relationships)} relationships for {target_file}"
+        )
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        logger.error(f"Error in search_code_references: {str(e)}")
+        result = {
+            "status": "error",
+            "message": f"Failed to search reference code: {str(e)}",
+            "target_file": target_file,
+            "indexes_path": indexes_path,
+        }
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+@mcp.tool()
+async def get_indexes_overview(indexes_path: str) -> str:
+    """
+    Get overview of all available reference code index information from specified directory
+
+    Args:
+        indexes_path: Path to the indexes directory containing JSON index files
+
+    Returns:
+        Overview information of all available reference code JSON string
+    """
+    try:
+        # Load index files from specified directory
+        index_cache = load_index_files_from_directory(indexes_path)
+
+        if not index_cache:
+            result = {
+                "status": "error",
+                "message": f"No index files found in: {indexes_path}",
+                "indexes_path": indexes_path,
+            }
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        overview = {"total_repos": len(index_cache), "repositories": {}}
+
+        for repo_name, index_data in index_cache.items():
+            repo_info = {
+                "repo_name": index_data.get("repo_name", repo_name),
+                "total_files": index_data.get("total_files", 0),
+                "file_types": [],
+                "main_concepts": [],
+                "total_relationships": len(index_data.get("relationships", [])),
+            }
+
+            # Collect file types and concepts
+            file_summaries = index_data.get("file_summaries", [])
+            file_types = set()
+            concepts = set()
+
+            for file_summary in file_summaries:
+                file_types.add(file_summary.get("file_type", "Unknown"))
+                concepts.update(file_summary.get("key_concepts", []))
+
+            repo_info["file_types"] = sorted(list(file_types))
+            repo_info["main_concepts"] = sorted(list(concepts))[
+                :20
+            ]  # Limit concept count
+
+            overview["repositories"][repo_name] = repo_info
+
+        result = {
+            "status": "success",
+            "overview": overview,
+            "indexes_directory": str(Path(indexes_path).resolve()),
+            "total_indexes_loaded": len(index_cache),
+        }
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    except Exception as e:
+        result = {
+            "status": "error",
+            "message": f"Failed to get indexes overview: {str(e)}",
+            "indexes_path": indexes_path,
+        }
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+def main():
+    """Main function"""
+    logger.info("Starting unified Code Reference Indexer MCP server")
+    logger.info("Available tools:")
+    logger.info(
+        "1. search_code_references(indexes_path, target_file, keywords, max_results) - UNIFIED TOOL"
+    )
+    logger.info(
+        "2. get_indexes_overview(indexes_path) - Get overview of available indexes"
+    )
+
+    # Run MCP server
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

projects/ui/DeepCode/tools/command_executor.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""
+Command Executor MCP Tool / 命令执行器 MCP 工具
+
+专门负责执行LLM生成的shell命令来创建文件树结构
+Specialized in executing LLM-generated shell commands to create file tree structures
+"""
+
+import subprocess
+from pathlib import Path
+from typing import List, Dict
+from mcp.server.models import InitializationOptions
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+import mcp.server.stdio
+
+# 创建MCP服务器实例 / Create MCP server instance
+app = Server("command-executor")
+
+
+@app.list_tools()
+async def handle_list_tools() -> list[types.Tool]:
+    """
+    列出可用工具 / List available tools
+    """
+    return [
+        types.Tool(
+            name="execute_commands",
+            description="""
+            执行shell命令列表来创建文件树结构
+            Execute shell command list to create file tree structure
+
+            Args:
+                commands: 要执行的shell命令列表（每行一个命令）
+                working_directory: 执行命令的工作目录
+
+            Returns:
+                命令执行结果和详细报告
+            """,
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "commands": {
+                        "type": "string",
+                        "title": "Commands",
+                        "description": "要执行的shell命令列表，每行一个命令",
+                    },
+                    "working_directory": {
+                        "type": "string",
+                        "title": "Working Directory",
+                        "description": "执行命令的工作目录",
+                    },
+                },
+                "required": ["commands", "working_directory"],
+            },
+        ),
+        types.Tool(
+            name="execute_single_command",
+            description="""
+            执行单个shell命令
+            Execute single shell command
+
+            Args:
+                command: 要执行的单个命令
+                working_directory: 执行命令的工作目录
+
+            Returns:
+                命令执行结果
+            """,
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "title": "Command",
+                        "description": "要执行的单个shell命令",
+                    },
+                    "working_directory": {
+                        "type": "string",
+                        "title": "Working Directory",
+                        "description": "执行命令的工作目录",
+                    },
+                },
+                "required": ["command", "working_directory"],
+            },
+        ),
+    ]
+
+
+@app.call_tool()
+async def handle_call_tool(name: str, arguments: dict) -> list[types.TextContent]:
+    """
+    处理工具调用 / Handle tool calls
+    """
+    try:
+        if name == "execute_commands":
+            return await execute_command_batch(
+                arguments.get("commands", ""), arguments.get("working_directory", ".")
+            )
+        elif name == "execute_single_command":
+            return await execute_single_command(
+                arguments.get("command", ""), arguments.get("working_directory", ".")
+            )
+        else:
+            raise ValueError(f"未知工具 / Unknown tool: {name}")
+
+    except Exception as e:
+        return [
+            types.TextContent(
+                type="text",
+                text=f"工具执行错误 / Error executing tool {name}: {str(e)}",
+            )
+        ]
+
+
+async def execute_command_batch(
+    commands: str, working_directory: str
+) -> list[types.TextContent]:
+    """
+    执行多个shell命令 / Execute multiple shell commands
+
+    Args:
+        commands: 命令列表，每行一个命令 / Command list, one command per line
+        working_directory: 工作目录 / Working directory
+
+    Returns:
+        执行结果 / Execution results
+    """
+    try:
+        # 确保工作目录存在 / Ensure working directory exists
+        Path(working_directory).mkdir(parents=True, exist_ok=True)
+
+        # 分割命令行 / Split command lines
+        command_lines = [
+            cmd.strip() for cmd in commands.strip().split("\n") if cmd.strip()
+        ]
+
+        if not command_lines:
+            return [
+                types.TextContent(
+                    type="text", text="没有提供有效命令 / No valid commands provided"
+                )
+            ]
+
+        results = []
+        stats = {"successful": 0, "failed": 0, "timeout": 0}
+
+        for i, command in enumerate(command_lines, 1):
+            try:
+                # 执行命令 / Execute command
+                result = subprocess.run(
+                    command,
+                    shell=True,
+                    cwd=working_directory,
+                    capture_output=True,
+                    text=True,
+                    timeout=30,  # 30秒超时
+                )
+
+                if result.returncode == 0:
+                    results.append(f"✅ Command {i}: {command}")
+                    if result.stdout.strip():
+                        results.append(f"   输出 / Output: {result.stdout.strip()}")
+                    stats["successful"] += 1
+                else:
+                    results.append(f"❌ Command {i}: {command}")
+                    if result.stderr.strip():
+                        results.append(f"   错误 / Error: {result.stderr.strip()}")
+                    stats["failed"] += 1
+
+            except subprocess.TimeoutExpired:
+                results.append(f"⏱️ Command {i} 超时 / timeout: {command}")
+                stats["timeout"] += 1
+            except Exception as e:
+                results.append(f"💥 Command {i} 异常 / exception: {command} - {str(e)}")
+                stats["failed"] += 1
+
+        # 生成执行报告 / Generate execution report
+        summary = generate_execution_summary(working_directory, command_lines, stats)
+        final_result = summary + "\n" + "\n".join(results)
+
+        return [types.TextContent(type="text", text=final_result)]
+
+    except Exception as e:
+        return [
+            types.TextContent(
+                type="text",
+                text=f"批量命令执行失败 / Failed to execute command batch: {str(e)}",
+            )
+        ]
+
+
+async def execute_single_command(
+    command: str, working_directory: str
+) -> list[types.TextContent]:
+    """
+    执行单个shell命令 / Execute single shell command
+
+    Args:
+        command: 要执行的命令 / Command to execute
+        working_directory: 工作目录 / Working directory
+
+    Returns:
+        执行结果 / Execution result
+    """
+    try:
+        # 确保工作目录存在 / Ensure working directory exists
+        Path(working_directory).mkdir(parents=True, exist_ok=True)
+
+        # 执行命令 / Execute command
+        result = subprocess.run(
+            command,
+            shell=True,
+            cwd=working_directory,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        # 格式化输出 / Format output
+        output = format_single_command_result(command, working_directory, result)
+
+        return [types.TextContent(type="text", text=output)]
+
+    except subprocess.TimeoutExpired:
+        return [
+            types.TextContent(
+                type="text", text=f"⏱️ 命令超时 / Command timeout: {command}"
+            )
+        ]
+    except Exception as e:
+        return [
+            types.TextContent(
+                type="text", text=f"💥 命令执行错误 / Command execution error: {str(e)}"
+            )
+        ]
+
+
+def generate_execution_summary(
+    working_directory: str, command_lines: List[str], stats: Dict[str, int]
+) -> str:
+    """
+    生成执行总结 / Generate execution summary
+
+    Args:
+        working_directory: 工作目录 / Working directory
+        command_lines: 命令列表 / Command list
+        stats: 统计信息 / Statistics
+
+    Returns:
+        格式化的总结 / Formatted summary
+    """
+    return f"""
+命令执行总结 / Command Execution Summary:
+{'='*50}
+工作目录 / Working Directory: {working_directory}
+总命令数 / Total Commands: {len(command_lines)}
+成功 / Successful: {stats['successful']}
+失败 / Failed: {stats['failed']}
+超时 / Timeout: {stats['timeout']}
+
+详细结果 / Detailed Results:
+{'-'*50}"""
+
+
+def format_single_command_result(
+    command: str, working_directory: str, result: subprocess.CompletedProcess
+) -> str:
+    """
+    格式化单命令执行结果 / Format single command execution result
+
+    Args:
+        command: 执行的命令 / Executed command
+        working_directory: 工作目录 / Working directory
+        result: 执行结果 / Execution result
+
+    Returns:
+        格式化的结果 / Formatted result
+    """
+    output = f"""
+单命令执行 / Single Command Execution:
+{'='*40}
+工作目录 / Working Directory: {working_directory}
+命令 / Command: {command}
+返回码 / Return Code: {result.returncode}
+
+"""
+
+    if result.returncode == 0:
+        output += "✅ 状态 / Status: SUCCESS / 成功\n"
+        if result.stdout.strip():
+            output += f"输出 / Output:\n{result.stdout.strip()}\n"
+    else:
+        output += "❌ 状态 / Status: FAILED / 失败\n"
+        if result.stderr.strip():
+            output += f"错误 / Error:\n{result.stderr.strip()}\n"
+
+    return output
+
+
+async def main():
+    """
+    运行MCP服务器 / Run MCP server
+    """
+    # 通过stdio运行服务器 / Run server via stdio
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await app.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="command-executor",
+                server_version="1.0.0",
+                capabilities=app.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

projects/ui/DeepCode/tools/document_segmentation_server.py

@@ -0,0 +1,1937 @@
+#!/usr/bin/env python3
+"""
+Document Segmentation MCP Server
+
+This MCP server provides intelligent document segmentation and retrieval functions for handling
+large research papers and technical documents that exceed LLM token limits.
+
+==== CORE FUNCTIONALITY ====
+1. Analyze document structure and type using semantic content analysis
+2. Create intelligent segments based on content semantics, not just structure
+3. Provide query-aware segment retrieval with relevance scoring
+4. Support both structured (papers with headers) and unstructured documents
+5. Configurable segmentation strategies based on document complexity
+
+==== MCP TOOLS PROVIDED ====
+
+📄 analyze_and_segment_document(paper_dir: str, force_refresh: bool = False)
+   Purpose: Analyzes document structure and creates intelligent segments
+   - Detects document type (research paper, technical doc, algorithm-focused, etc.)
+   - Selects optimal segmentation strategy based on content analysis
+   - Creates semantic segments preserving algorithm and concept integrity
+   - Stores segmentation index for efficient retrieval
+   - Returns: JSON with segmentation status, strategy used, and segment count
+
+📖 read_document_segments(paper_dir: str, query_type: str, keywords: List[str] = None,
+                         max_segments: int = 3, max_total_chars: int = None)
+   Purpose: Intelligently retrieves relevant document segments based on query context
+   - query_type: "concept_analysis", "algorithm_extraction", or "code_planning"
+   - Uses semantic relevance scoring to rank segments
+   - Applies query-specific filtering and keyword matching
+   - Dynamically calculates optimal character limits based on content complexity
+   - Returns: JSON with selected segments optimized for the specific query type
+
+📋 get_document_overview(paper_dir: str)
+   Purpose: Provides high-level overview of document structure and available segments
+   - Shows document type and segmentation strategy used
+   - Lists all segments with titles, content types, and relevance scores
+   - Displays segment statistics (character counts, keyword summaries)
+   - Returns: JSON with complete document analysis metadata
+
+==== SEGMENTATION STRATEGIES ====
+- semantic_research_focused: For academic papers with complex algorithmic content
+- algorithm_preserve_integrity: Maintains algorithm blocks and formula chains intact
+- concept_implementation_hybrid: Merges related concepts with implementation details
+- semantic_chunking_enhanced: Advanced boundary detection for long documents
+- content_aware_segmentation: Adaptive chunking based on content density
+
+==== INTELLIGENT FEATURES ====
+- Semantic boundary detection (not just structural)
+- Algorithm block identification and preservation
+- Formula chain recognition and grouping
+- Concept-implementation relationship mapping
+- Multi-level relevance scoring (content type, importance, keyword matching)
+- Backward compatibility with existing document indexes
+- Configurable via mcp_agent.config.yaml (enabled/disabled, size thresholds)
+
+Usage:
+python tools/document_segmentation_server.py
+"""
+
+import os
+import re
+import json
+import sys
+import io
+from typing import Dict, List, Tuple
+import hashlib
+import logging
+from datetime import datetime
+from dataclasses import dataclass, asdict
+
+# Set standard output encoding to UTF-8
+if sys.stdout.encoding != "utf-8":
+    try:
+        if hasattr(sys.stdout, "reconfigure"):
+            sys.stdout.reconfigure(encoding="utf-8")
+            sys.stderr.reconfigure(encoding="utf-8")
+        else:
+            sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding="utf-8")
+            sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding="utf-8")
+    except Exception as e:
+        print(f"Warning: Could not set UTF-8 encoding: {e}")
+
+# Import MCP related modules
+from mcp.server.fastmcp import FastMCP
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create FastMCP server instance
+mcp = FastMCP("document-segmentation-server")
+
+
+@dataclass
+class DocumentSegment:
+    """Represents a document segment with metadata"""
+
+    id: str
+    title: str
+    content: str
+    content_type: str  # "introduction", "methodology", "algorithm", "results", etc.
+    keywords: List[str]
+    char_start: int
+    char_end: int
+    char_count: int
+    relevance_scores: Dict[str, float]  # Scores for different query types
+    section_path: str  # e.g., "3.2.1" for nested sections
+
+
+@dataclass
+class DocumentIndex:
+    """Document index containing all segments and metadata"""
+
+    document_path: str
+    document_type: str  # "academic_paper", "technical_doc", "code_doc", "general"
+    segmentation_strategy: str
+    total_segments: int
+    total_chars: int
+    segments: List[DocumentSegment]
+    created_at: str
+
+
+class DocumentAnalyzer:
+    """Enhanced document analyzer using semantic content analysis instead of mechanical structure detection"""
+
+    # More precise semantic indicators, weighted by importance
+    ALGORITHM_INDICATORS = {
+        "high": [
+            "algorithm",
+            "procedure",
+            "method",
+            "approach",
+            "technique",
+            "framework",
+        ],
+        "medium": ["step", "process", "implementation", "computation", "calculation"],
+        "low": ["example", "illustration", "demonstration"],
+    }
+
+    TECHNICAL_CONCEPT_INDICATORS = {
+        "high": ["formula", "equation", "theorem", "lemma", "proof", "definition"],
+        "medium": ["parameter", "variable", "function", "model", "architecture"],
+        "low": ["notation", "symbol", "term"],
+    }
+
+    IMPLEMENTATION_INDICATORS = {
+        "high": ["code", "implementation", "programming", "software", "system"],
+        "medium": ["design", "structure", "module", "component", "interface"],
+        "low": ["tool", "library", "package"],
+    }
+
+    # Semantic features of document types (not just based on titles)
+    RESEARCH_PAPER_PATTERNS = [
+        r"(?i)\babstract\b.*?\n.*?(introduction|motivation|background)",
+        r"(?i)(methodology|method).*?(experiment|evaluation|result)",
+        r"(?i)(conclusion|future work|limitation).*?(reference|bibliography)",
+        r"(?i)(related work|literature review|prior art)",
+    ]
+
+    TECHNICAL_DOC_PATTERNS = [
+        r"(?i)(getting started|installation|setup).*?(usage|example)",
+        r"(?i)(api|interface|specification).*?(parameter|endpoint)",
+        r"(?i)(tutorial|guide|walkthrough).*?(step|instruction)",
+        r"(?i)(troubleshooting|faq|common issues)",
+    ]
+
+    def analyze_document_type(self, content: str) -> Tuple[str, float]:
+        """
+        Enhanced document type analysis based on semantic content patterns
+
+        Returns:
+            Tuple[str, float]: (document_type, confidence_score)
+        """
+        content_lower = content.lower()
+
+        # Calculate weighted semantic indicator scores
+        algorithm_score = self._calculate_weighted_score(
+            content_lower, self.ALGORITHM_INDICATORS
+        )
+        concept_score = self._calculate_weighted_score(
+            content_lower, self.TECHNICAL_CONCEPT_INDICATORS
+        )
+        implementation_score = self._calculate_weighted_score(
+            content_lower, self.IMPLEMENTATION_INDICATORS
+        )
+
+        # Detect semantic patterns of document types
+        research_pattern_score = self._detect_pattern_score(
+            content, self.RESEARCH_PAPER_PATTERNS
+        )
+        technical_pattern_score = self._detect_pattern_score(
+            content, self.TECHNICAL_DOC_PATTERNS
+        )
+
+        # Comprehensive evaluation of document type
+        total_research_score = (
+            algorithm_score + concept_score + research_pattern_score * 2
+        )
+        total_technical_score = implementation_score + technical_pattern_score * 2
+
+        # Determine document type based on content density and pattern matching
+        if research_pattern_score > 0.5 and total_research_score > 3.0:
+            return "research_paper", min(0.95, 0.6 + research_pattern_score * 0.35)
+        elif algorithm_score > 2.0 and concept_score > 1.5:
+            return "algorithm_focused", 0.85
+        elif total_technical_score > 2.5:
+            return "technical_doc", 0.8
+        elif implementation_score > 1.5:
+            return "implementation_guide", 0.75
+        else:
+            return "general_document", 0.5
+
+    def _calculate_weighted_score(
+        self, content: str, indicators: Dict[str, List[str]]
+    ) -> float:
+        """Calculate weighted semantic indicator scores"""
+        score = 0.0
+        for weight_level, terms in indicators.items():
+            weight = {"high": 3.0, "medium": 2.0, "low": 1.0}[weight_level]
+            for term in terms:
+                if term in content:
+                    score += weight * (
+                        content.count(term) * 0.5 + 1
+                    )  # Consider term frequency
+        return score
+
+    def _detect_pattern_score(self, content: str, patterns: List[str]) -> float:
+        """Detect semantic pattern matching scores"""
+        matches = 0
+        for pattern in patterns:
+            if re.search(pattern, content, re.DOTALL):
+                matches += 1
+        return matches / len(patterns)
+
+    def detect_segmentation_strategy(self, content: str, doc_type: str) -> str:
+        """
+        Intelligently determine the best segmentation strategy based on content semantics rather than mechanical structure
+        """
+        # Analyze content characteristics
+        algorithm_density = self._calculate_algorithm_density(content)
+        concept_complexity = self._calculate_concept_complexity(content)
+        implementation_detail_level = self._calculate_implementation_detail_level(
+            content
+        )
+
+        # Select strategy based on document type and content characteristics
+        if doc_type == "research_paper" and algorithm_density > 0.3:
+            return "semantic_research_focused"
+        elif doc_type == "algorithm_focused" or algorithm_density > 0.5:
+            return "algorithm_preserve_integrity"
+        elif concept_complexity > 0.4 and implementation_detail_level > 0.3:
+            return "concept_implementation_hybrid"
+        elif len(content) > 15000:  # Long documents
+            return "semantic_chunking_enhanced"
+        else:
+            return "content_aware_segmentation"
+
+    def _calculate_algorithm_density(self, content: str) -> float:
+        """Calculate algorithm content density"""
+        total_chars = len(content)
+        algorithm_chars = 0
+
+        # Identify algorithm blocks
+        algorithm_patterns = [
+            r"(?i)(algorithm\s+\d+|procedure\s+\d+)",
+            r"(?i)(step\s+\d+|phase\s+\d+)",
+            r"(?i)(input:|output:|return:|initialize:)",
+            r"(?i)(for\s+each|while|if.*then|else)",
+            r"(?i)(function|method|procedure).*\(",
+        ]
+
+        for pattern in algorithm_patterns:
+            matches = re.finditer(pattern, content)
+            for match in matches:
+                # Estimate algorithm block size (expand forward and backward from match point)
+                start = max(0, match.start() - 200)
+                end = min(len(content), match.end() + 800)
+                algorithm_chars += end - start
+
+        return min(1.0, algorithm_chars / total_chars)
+
+    def _calculate_concept_complexity(self, content: str) -> float:
+        """Calculate concept complexity"""
+        concept_indicators = self.TECHNICAL_CONCEPT_INDICATORS
+        complexity_score = 0.0
+
+        for level, terms in concept_indicators.items():
+            weight = {"high": 3.0, "medium": 2.0, "low": 1.0}[level]
+            for term in terms:
+                complexity_score += content.lower().count(term) * weight
+
+        # Normalize to 0-1 range
+        return min(1.0, complexity_score / 100)
+
+    def _calculate_implementation_detail_level(self, content: str) -> float:
+        """Calculate implementation detail level"""
+        implementation_patterns = [
+            r"(?i)(code|implementation|programming)",
+            r"(?i)(class|function|method|variable)",
+            r"(?i)(import|include|library)",
+            r"(?i)(parameter|argument|return)",
+            r"(?i)(example|demo|tutorial)",
+        ]
+
+        detail_score = 0
+        for pattern in implementation_patterns:
+            detail_score += len(re.findall(pattern, content))
+
+        return min(1.0, detail_score / 50)
+
+
+class DocumentSegmenter:
+    """Creates intelligent segments from documents"""
+
+    def __init__(self):
+        self.analyzer = DocumentAnalyzer()
+
+    def segment_document(self, content: str, strategy: str) -> List[DocumentSegment]:
+        """
+        Perform intelligent segmentation using the specified strategy
+        """
+        if strategy == "semantic_research_focused":
+            return self._segment_research_paper_semantically(content)
+        elif strategy == "algorithm_preserve_integrity":
+            return self._segment_preserve_algorithm_integrity(content)
+        elif strategy == "concept_implementation_hybrid":
+            return self._segment_concept_implementation_hybrid(content)
+        elif strategy == "semantic_chunking_enhanced":
+            return self._segment_by_enhanced_semantic_chunks(content)
+        elif strategy == "content_aware_segmentation":
+            return self._segment_content_aware(content)
+        else:
+            # Compatibility with legacy strategies
+            return self._segment_by_enhanced_semantic_chunks(content)
+
+    def _segment_by_headers(self, content: str) -> List[DocumentSegment]:
+        """Segment document based on markdown headers"""
+        segments = []
+        lines = content.split("\n")
+        current_segment = []
+        current_header = None
+        char_pos = 0
+
+        for line in lines:
+            line_with_newline = line + "\n"
+
+            # Check if line is a header
+            header_match = re.match(r"^(#{1,6})\s+(.+)$", line)
+
+            if header_match:
+                # Save previous segment if exists
+                if current_segment and current_header:
+                    segment_content = "\n".join(current_segment).strip()
+                    if segment_content:
+                        # Analyze content type and importance
+                        content_type = self._classify_content_type(
+                            current_header, segment_content
+                        )
+                        importance_score = (
+                            0.8 if content_type in ["algorithm", "formula"] else 0.7
+                        )
+
+                        segment = self._create_enhanced_segment(
+                            segment_content,
+                            current_header,
+                            char_pos - len(segment_content.encode("utf-8")),
+                            char_pos,
+                            importance_score,
+                            content_type,
+                        )
+                        segments.append(segment)
+
+                # Start new segment
+                current_header = header_match.group(2).strip()
+                current_segment = [line]
+            else:
+                if current_segment is not None:
+                    current_segment.append(line)
+
+            char_pos += len(line_with_newline.encode("utf-8"))
+
+        # Add final segment
+        if current_segment and current_header:
+            segment_content = "\n".join(current_segment).strip()
+            if segment_content:
+                # Analyze content type and importance
+                content_type = self._classify_content_type(
+                    current_header, segment_content
+                )
+                importance_score = (
+                    0.8 if content_type in ["algorithm", "formula"] else 0.7
+                )
+
+                segment = self._create_enhanced_segment(
+                    segment_content,
+                    current_header,
+                    char_pos - len(segment_content.encode("utf-8")),
+                    char_pos,
+                    importance_score,
+                    content_type,
+                )
+                segments.append(segment)
+
+        return segments
+
+    def _segment_preserve_algorithm_integrity(
+        self, content: str
+    ) -> List[DocumentSegment]:
+        """Smart segmentation strategy that preserves algorithm integrity"""
+        segments = []
+
+        # 1. Identify algorithm blocks and related descriptions
+        algorithm_blocks = self._identify_algorithm_blocks(content)
+
+        # 2. Identify concept definition groups
+        concept_groups = self._identify_concept_groups(content)
+
+        # 3. Identify formula derivation chains
+        formula_chains = self._identify_formula_chains(content)
+
+        # 4. Merge related content blocks to ensure integrity
+        content_blocks = self._merge_related_content_blocks(
+            algorithm_blocks, concept_groups, formula_chains, content
+        )
+
+        # 5. Convert to DocumentSegment
+        for i, block in enumerate(content_blocks):
+            segment = self._create_enhanced_segment(
+                block["content"],
+                block["title"],
+                block["start_pos"],
+                block["end_pos"],
+                block["importance_score"],
+                block["content_type"],
+            )
+            segments.append(segment)
+
+        return segments
+
+    def _segment_research_paper_semantically(
+        self, content: str
+    ) -> List[DocumentSegment]:
+        """Semantic segmentation specifically for research papers"""
+        segments = []
+
+        # Identify semantic structure of research papers
+        paper_sections = self._identify_research_paper_sections(content)
+
+        for section in paper_sections:
+            # Ensure each section contains sufficient context
+            enhanced_content = self._enhance_section_with_context(section, content)
+
+            segment = self._create_enhanced_segment(
+                enhanced_content["content"],
+                enhanced_content["title"],
+                enhanced_content["start_pos"],
+                enhanced_content["end_pos"],
+                enhanced_content["importance_score"],
+                enhanced_content["content_type"],
+            )
+            segments.append(segment)
+
+        return segments
+
+    def _segment_concept_implementation_hybrid(
+        self, content: str
+    ) -> List[DocumentSegment]:
+        """Intelligent segmentation combining concepts and implementation"""
+        segments = []
+
+        # Identify concept-implementation correspondence
+        concept_impl_pairs = self._identify_concept_implementation_pairs(content)
+
+        for pair in concept_impl_pairs:
+            # Merge related concepts and implementations into one segment
+            merged_content = self._merge_concept_with_implementation(pair, content)
+
+            segment = self._create_enhanced_segment(
+                merged_content["content"],
+                merged_content["title"],
+                merged_content["start_pos"],
+                merged_content["end_pos"],
+                merged_content["importance_score"],
+                merged_content["content_type"],
+            )
+            segments.append(segment)
+
+        return segments
+
+    def _segment_by_enhanced_semantic_chunks(
+        self, content: str
+    ) -> List[DocumentSegment]:
+        """Enhanced semantic chunk segmentation"""
+        segments = []
+
+        # Use improved semantic boundary detection
+        semantic_boundaries = self._detect_semantic_boundaries(content)
+
+        current_start = 0
+        for i, boundary in enumerate(semantic_boundaries):
+            chunk_content = content[current_start : boundary["position"]]
+
+            if len(chunk_content.strip()) > 200:  # Minimum content threshold
+                segment = self._create_enhanced_segment(
+                    chunk_content,
+                    boundary["suggested_title"],
+                    current_start,
+                    boundary["position"],
+                    boundary["importance_score"],
+                    boundary["content_type"],
+                )
+                segments.append(segment)
+
+            current_start = boundary["position"]
+
+        # Handle the final segment
+        if current_start < len(content):
+            final_content = content[current_start:]
+            if len(final_content.strip()) > 200:
+                segment = self._create_enhanced_segment(
+                    final_content,
+                    "Final Section",
+                    current_start,
+                    len(content),
+                    0.7,
+                    "general",
+                )
+                segments.append(segment)
+
+        return segments
+
+    def _segment_content_aware(self, content: str) -> List[DocumentSegment]:
+        """Content-aware intelligent segmentation"""
+        segments = []
+
+        # Adaptive segmentation size
+        optimal_chunk_size = self._calculate_optimal_chunk_size(content)
+
+        # Segment based on content density
+        content_chunks = self._create_content_aware_chunks(content, optimal_chunk_size)
+
+        for chunk in content_chunks:
+            segment = self._create_enhanced_segment(
+                chunk["content"],
+                chunk["title"],
+                chunk["start_pos"],
+                chunk["end_pos"],
+                chunk["importance_score"],
+                chunk["content_type"],
+            )
+            segments.append(segment)
+
+        return segments
+
+    def _segment_academic_paper(self, content: str) -> List[DocumentSegment]:
+        """Segment academic paper using semantic understanding"""
+        # First try header-based segmentation
+        headers = re.findall(r"^(#{1,6})\s+(.+)$", content, re.MULTILINE)
+        if len(headers) >= 2:
+            return self._segment_by_headers(content)
+
+        # Fallback to semantic detection of academic sections
+        sections = self._detect_academic_sections(content)
+        segments = []
+
+        for section in sections:
+            # Determine importance based on section type
+            section_type = section.get("type", "general")
+            content_type = (
+                section_type
+                if section_type
+                in ["algorithm", "formula", "introduction", "conclusion"]
+                else "general"
+            )
+            importance_score = {
+                "algorithm": 0.95,
+                "formula": 0.9,
+                "introduction": 0.85,
+                "conclusion": 0.8,
+            }.get(content_type, 0.7)
+
+            segment = self._create_enhanced_segment(
+                section["content"],
+                section["title"],
+                section["start_pos"],
+                section["end_pos"],
+                importance_score,
+                content_type,
+            )
+            segments.append(segment)
+
+        return segments
+
+    def _detect_academic_sections(self, content: str) -> List[Dict]:
+        """Detect academic paper sections even without clear headers"""
+        sections = []
+
+        # Common academic section patterns
+        section_patterns = [
+            (r"(?i)(abstract|摘要)", "introduction"),
+            (r"(?i)(introduction|引言|简介)", "introduction"),
+            (r"(?i)(related work|相关工作|背景)", "background"),
+            (r"(?i)(method|methodology|approach|方法)", "methodology"),
+            (r"(?i)(algorithm|算法)", "algorithm"),
+            (r"(?i)(experiment|实验|evaluation|评估)", "experiment"),
+            (r"(?i)(result|结果|finding)", "results"),
+            (r"(?i)(conclusion|结论|总结)", "conclusion"),
+            (r"(?i)(reference|参考文献|bibliography)", "references"),
+        ]
+
+        current_pos = 0
+        for i, (pattern, section_type) in enumerate(section_patterns):
+            match = re.search(pattern, content[current_pos:], re.IGNORECASE)
+            if match:
+                start_pos = current_pos + match.start()
+
+                # Find end position (next section or end of document)
+                next_pos = len(content)
+                for next_pattern, _ in section_patterns[i + 1 :]:
+                    next_match = re.search(
+                        next_pattern, content[start_pos + 100 :], re.IGNORECASE
+                    )
+                    if next_match:
+                        next_pos = start_pos + 100 + next_match.start()
+                        break
+
+                section_content = content[start_pos:next_pos].strip()
+                if len(section_content) > 50:  # Minimum content length
+                    # Calculate importance score and content type
+                    importance_score = self._calculate_paragraph_importance(
+                        section_content, section_type
+                    )
+                    content_type = self._classify_content_type(
+                        match.group(1), section_content
+                    )
+
+                    sections.append(
+                        {
+                            "title": match.group(1),
+                            "content": section_content,
+                            "start_pos": start_pos,
+                            "end_pos": next_pos,
+                            "type": section_type,
+                            "importance_score": importance_score,
+                            "content_type": content_type,
+                        }
+                    )
+
+                current_pos = next_pos
+
+        return sections
+
+    def _segment_by_semantic_chunks(self, content: str) -> List[DocumentSegment]:
+        """Segment long documents into semantic chunks"""
+        # Split into paragraphs first
+        paragraphs = [p.strip() for p in content.split("\n\n") if p.strip()]
+
+        segments = []
+        current_chunk = []
+        current_chunk_size = 0
+        chunk_size_limit = 3000  # characters
+        overlap_size = 200
+
+        char_pos = 0
+
+        for para in paragraphs:
+            para_size = len(para)
+
+            # If adding this paragraph exceeds limit, create a segment
+            if current_chunk_size + para_size > chunk_size_limit and current_chunk:
+                chunk_content = "\n\n".join(current_chunk)
+                # Analyze semantic chunk content type
+                content_type = self._classify_paragraph_type(chunk_content)
+                importance_score = self._calculate_paragraph_importance(
+                    chunk_content, content_type
+                )
+
+                segment = self._create_enhanced_segment(
+                    chunk_content,
+                    f"Section {len(segments) + 1}",
+                    char_pos - len(chunk_content.encode("utf-8")),
+                    char_pos,
+                    importance_score,
+                    content_type,
+                )
+                segments.append(segment)
+
+                # Keep last part for overlap
+                overlap_content = (
+                    chunk_content[-overlap_size:]
+                    if len(chunk_content) > overlap_size
+                    else ""
+                )
+                current_chunk = [overlap_content, para] if overlap_content else [para]
+                current_chunk_size = len(overlap_content) + para_size
+            else:
+                current_chunk.append(para)
+                current_chunk_size += para_size
+
+            char_pos += para_size + 2  # +2 for \n\n
+
+        # Add final chunk
+        if current_chunk:
+            chunk_content = "\n\n".join(current_chunk)
+            # Analyze final chunk content type
+            content_type = self._classify_paragraph_type(chunk_content)
+            importance_score = self._calculate_paragraph_importance(
+                chunk_content, content_type
+            )
+
+            segment = self._create_enhanced_segment(
+                chunk_content,
+                f"Section {len(segments) + 1}",
+                char_pos - len(chunk_content.encode("utf-8")),
+                char_pos,
+                importance_score,
+                content_type,
+            )
+            segments.append(segment)
+
+        return segments
+
+    def _segment_by_paragraphs(self, content: str) -> List[DocumentSegment]:
+        """Simple paragraph-based segmentation for short documents"""
+        paragraphs = [p.strip() for p in content.split("\n\n") if p.strip()]
+        segments = []
+        char_pos = 0
+
+        for i, para in enumerate(paragraphs):
+            if len(para) > 100:  # Only include substantial paragraphs
+                # Analyze paragraph type and importance
+                content_type = self._classify_paragraph_type(para)
+                importance_score = self._calculate_paragraph_importance(
+                    para, content_type
+                )
+
+                segment = self._create_enhanced_segment(
+                    para,
+                    f"Paragraph {i + 1}",
+                    char_pos,
+                    char_pos + len(para.encode("utf-8")),
+                    importance_score,
+                    content_type,
+                )
+                segments.append(segment)
+            char_pos += len(para.encode("utf-8")) + 2
+
+        return segments
+
+    # =============== Enhanced intelligent segmentation helper methods ===============
+
+    def _identify_algorithm_blocks(self, content: str) -> List[Dict]:
+        """Identify algorithm blocks and related descriptions"""
+        algorithm_blocks = []
+
+        # Algorithm block identification patterns
+        algorithm_patterns = [
+            r"(?i)(algorithm\s+\d+|procedure\s+\d+|method\s+\d+).*?(?=algorithm\s+\d+|procedure\s+\d+|method\s+\d+|$)",
+            r"(?i)(input:|output:|returns?:|require:|ensure:).*?(?=\n\s*\n|\n\s*(?:input:|output:|returns?:|require:|ensure:)|$)",
+            r"(?i)(for\s+each|while|if.*then|repeat.*until).*?(?=\n\s*\n|$)",
+            r"(?i)(step\s+\d+|phase\s+\d+).*?(?=step\s+\d+|phase\s+\d+|\n\s*\n|$)",
+        ]
+
+        for pattern in algorithm_patterns:
+            matches = re.finditer(pattern, content, re.DOTALL)
+            for match in matches:
+                # Expand context to include complete descriptions
+                start = max(0, match.start() - 300)
+                end = min(len(content), match.end() + 500)
+
+                # Find natural boundaries
+                while start > 0 and content[start] not in "\n.!?":
+                    start -= 1
+                while end < len(content) and content[end] not in "\n.!?":
+                    end += 1
+
+                algorithm_blocks.append(
+                    {
+                        "start_pos": start,
+                        "end_pos": end,
+                        "content": content[start:end].strip(),
+                        "title": self._extract_algorithm_title(
+                            content[match.start() : match.end()]
+                        ),
+                        "importance_score": 0.95,  # High importance for algorithm blocks
+                        "content_type": "algorithm",
+                    }
+                )
+
+        return algorithm_blocks
+
+    def _identify_concept_groups(self, content: str) -> List[Dict]:
+        """Identify concept definition groups"""
+        concept_groups = []
+
+        # Concept definition patterns
+        concept_patterns = [
+            r"(?i)(definition|define|let|denote|given).*?(?=\n\s*\n|definition|define|let|denote|$)",
+            r"(?i)(theorem|lemma|proposition|corollary).*?(?=\n\s*\n|theorem|lemma|proposition|corollary|$)",
+            r"(?i)(notation|symbol|parameter).*?(?=\n\s*\n|notation|symbol|parameter|$)",
+        ]
+
+        for pattern in concept_patterns:
+            matches = re.finditer(pattern, content, re.DOTALL)
+            for match in matches:
+                # Expand context
+                start = max(0, match.start() - 200)
+                end = min(len(content), match.end() + 300)
+
+                concept_groups.append(
+                    {
+                        "start_pos": start,
+                        "end_pos": end,
+                        "content": content[start:end].strip(),
+                        "title": self._extract_concept_title(
+                            content[match.start() : match.end()]
+                        ),
+                        "importance_score": 0.85,
+                        "content_type": "concept",
+                    }
+                )
+
+        return concept_groups
+
+    def _identify_formula_chains(self, content: str) -> List[Dict]:
+        """Identify formula derivation chains"""
+        formula_chains = []
+
+        # Formula patterns
+        formula_patterns = [
+            r"\$\$.*?\$\$",  # Block-level mathematical formulas
+            r"\$[^$]+\$",  # Inline mathematical formulas
+            r"(?i)(equation|formula).*?(?=\n\s*\n|equation|formula|$)",
+            r"(?i)(where|such that|given that).*?(?=\n\s*\n|where|such that|given that|$)",
+        ]
+
+        # Find dense formula regions
+        formula_positions = []
+        for pattern in formula_patterns:
+            matches = re.finditer(pattern, content, re.DOTALL)
+            for match in matches:
+                formula_positions.append((match.start(), match.end()))
+
+        # Merge nearby formulas into formula chains
+        formula_positions.sort()
+        if formula_positions:
+            current_chain_start = formula_positions[0][0]
+            current_chain_end = formula_positions[0][1]
+
+            for start, end in formula_positions[1:]:
+                if (
+                    start - current_chain_end < 500
+                ):  # Merge formulas within 500 characters
+                    current_chain_end = end
+                else:
+                    # Save current chain
+                    formula_chains.append(
+                        {
+                            "start_pos": max(0, current_chain_start - 200),
+                            "end_pos": min(len(content), current_chain_end + 200),
+                            "content": content[
+                                max(0, current_chain_start - 200) : min(
+                                    len(content), current_chain_end + 200
+                                )
+                            ].strip(),
+                            "title": "Mathematical Formulation",
+                            "importance_score": 0.9,
+                            "content_type": "formula",
+                        }
+                    )
+                    current_chain_start = start
+                    current_chain_end = end
+
+            # Add the last chain
+            formula_chains.append(
+                {
+                    "start_pos": max(0, current_chain_start - 200),
+                    "end_pos": min(len(content), current_chain_end + 200),
+                    "content": content[
+                        max(0, current_chain_start - 200) : min(
+                            len(content), current_chain_end + 200
+                        )
+                    ].strip(),
+                    "title": "Mathematical Formulation",
+                    "importance_score": 0.9,
+                    "content_type": "formula",
+                }
+            )
+
+        return formula_chains
+
+    def _merge_related_content_blocks(
+        self,
+        algorithm_blocks: List[Dict],
+        concept_groups: List[Dict],
+        formula_chains: List[Dict],
+        content: str,
+    ) -> List[Dict]:
+        """Merge related content blocks to ensure integrity"""
+        all_blocks = algorithm_blocks + concept_groups + formula_chains
+        all_blocks.sort(key=lambda x: x["start_pos"])
+
+        merged_blocks = []
+        i = 0
+
+        while i < len(all_blocks):
+            current_block = all_blocks[i]
+
+            # Check if can merge with the next block
+            while i + 1 < len(all_blocks):
+                next_block = all_blocks[i + 1]
+
+                # If blocks are close or content related, merge them
+                if next_block["start_pos"] - current_block[
+                    "end_pos"
+                ] < 300 or self._are_blocks_related(current_block, next_block):
+                    # Merge blocks
+                    merged_content = content[
+                        current_block["start_pos"] : next_block["end_pos"]
+                    ]
+                    current_block = {
+                        "start_pos": current_block["start_pos"],
+                        "end_pos": next_block["end_pos"],
+                        "content": merged_content.strip(),
+                        "title": f"{current_block['title']} & {next_block['title']}",
+                        "importance_score": max(
+                            current_block["importance_score"],
+                            next_block["importance_score"],
+                        ),
+                        "content_type": "merged",
+                    }
+                    i += 1
+                else:
+                    break
+
+            merged_blocks.append(current_block)
+            i += 1
+
+        return merged_blocks
+
+    def _are_blocks_related(self, block1: Dict, block2: Dict) -> bool:
+        """Determine if two content blocks are related"""
+        # Check content type associations
+        related_types = [
+            ("algorithm", "formula"),
+            ("concept", "algorithm"),
+            ("formula", "concept"),
+        ]
+
+        for type1, type2 in related_types:
+            if (
+                block1["content_type"] == type1 and block2["content_type"] == type2
+            ) or (block1["content_type"] == type2 and block2["content_type"] == type1):
+                return True
+
+        return False
+
+    def _extract_algorithm_title(self, text: str) -> str:
+        """Extract title from algorithm text"""
+        lines = text.split("\n")[:3]  # First 3 lines
+        for line in lines:
+            line = line.strip()
+            if line and len(line) < 100:  # Reasonable title length
+                # Clean title
+                title = re.sub(r"[^\w\s-]", "", line)
+                if title:
+                    return title[:50]  # Limit title length
+        return "Algorithm Block"
+
+    def _extract_concept_title(self, text: str) -> str:
+        """Extract title from concept text"""
+        lines = text.split("\n")[:2]
+        for line in lines:
+            line = line.strip()
+            if line and len(line) < 80:
+                title = re.sub(r"[^\w\s-]", "", line)
+                if title:
+                    return title[:50]
+        return "Concept Definition"
+
+    def _create_enhanced_segment(
+        self,
+        content: str,
+        title: str,
+        start_pos: int,
+        end_pos: int,
+        importance_score: float,
+        content_type: str,
+    ) -> DocumentSegment:
+        """Create enhanced document segment"""
+        # Generate unique ID
+        segment_id = hashlib.md5(
+            f"{title}_{start_pos}_{end_pos}_{importance_score}".encode()
+        ).hexdigest()[:8]
+
+        # Extract keywords
+        keywords = self._extract_enhanced_keywords(content, content_type)
+
+        # Calculate enhanced relevance scores
+        relevance_scores = self._calculate_enhanced_relevance_scores(
+            content, content_type, importance_score
+        )
+
+        return DocumentSegment(
+            id=segment_id,
+            title=title,
+            content=content,
+            content_type=content_type,
+            keywords=keywords,
+            char_start=start_pos,
+            char_end=end_pos,
+            char_count=len(content),
+            relevance_scores=relevance_scores,
+            section_path=title,
+        )
+
+    def _extract_enhanced_keywords(self, content: str, content_type: str) -> List[str]:
+        """Extract enhanced keywords based on content type"""
+        words = re.findall(r"\b[a-zA-Z]{3,}\b", content.lower())
+
+        # Adjust stopwords based on content type
+        if content_type == "algorithm":
+            algorithm_stopwords = {
+                "step",
+                "then",
+                "else",
+                "end",
+                "begin",
+                "start",
+                "stop",
+            }
+            words = [w for w in words if w not in algorithm_stopwords]
+        elif content_type == "formula":
+            formula_keywords = ["equation", "formula", "where", "given", "such", "that"]
+            words.extend(formula_keywords)
+
+        # General stopwords
+        general_stopwords = {
+            "the",
+            "and",
+            "for",
+            "are",
+            "but",
+            "not",
+            "you",
+            "all",
+            "can",
+            "her",
+            "was",
+            "one",
+            "our",
+            "had",
+            "but",
+            "have",
+            "this",
+            "that",
+            "with",
+            "from",
+            "they",
+            "she",
+            "been",
+            "were",
+            "said",
+            "each",
+            "which",
+            "their",
+        }
+
+        keywords = [w for w in set(words) if w not in general_stopwords and len(w) > 3]
+        return keywords[:25]  # Increase keyword count
+
+    def _calculate_enhanced_relevance_scores(
+        self, content: str, content_type: str, importance_score: float
+    ) -> Dict[str, float]:
+        """Calculate enhanced relevance scores"""
+        content_lower = content.lower()
+
+        base_scores = {
+            "concept_analysis": 0.5,
+            "algorithm_extraction": 0.5,
+            "code_planning": 0.5,
+        }
+
+        # Adjust base scores based on content type and importance
+        if content_type == "algorithm":
+            base_scores["algorithm_extraction"] = importance_score
+            base_scores["code_planning"] = importance_score * 0.9
+            base_scores["concept_analysis"] = importance_score * 0.7
+        elif content_type == "concept":
+            base_scores["concept_analysis"] = importance_score
+            base_scores["algorithm_extraction"] = importance_score * 0.8
+            base_scores["code_planning"] = importance_score * 0.6
+        elif content_type == "formula":
+            base_scores["algorithm_extraction"] = importance_score
+            base_scores["concept_analysis"] = importance_score * 0.8
+            base_scores["code_planning"] = importance_score * 0.9
+        elif content_type == "merged":
+            # Merged content is usually important
+            base_scores = {k: importance_score * 0.95 for k in base_scores}
+
+        # Additional bonus based on content density
+        algorithm_indicators = ["algorithm", "method", "procedure", "step", "process"]
+        concept_indicators = ["definition", "concept", "framework", "approach"]
+        implementation_indicators = ["implementation", "code", "function", "design"]
+
+        for query_type, indicators in [
+            ("algorithm_extraction", algorithm_indicators),
+            ("concept_analysis", concept_indicators),
+            ("code_planning", implementation_indicators),
+        ]:
+            density_bonus = (
+                sum(1 for indicator in indicators if indicator in content_lower) * 0.1
+            )
+            base_scores[query_type] = min(1.0, base_scores[query_type] + density_bonus)
+
+        return base_scores
+
+    # Placeholder methods - can be further implemented later
+    def _identify_research_paper_sections(self, content: str) -> List[Dict]:
+        """Identify research paper sections - simplified implementation"""
+        # Temporarily use improved semantic detection
+        return self._detect_academic_sections(content)
+
+    def _enhance_section_with_context(self, section: Dict, content: str) -> Dict:
+        """Add context to sections - simplified implementation"""
+        return section
+
+    def _identify_concept_implementation_pairs(self, content: str) -> List[Dict]:
+        """Identify concept-implementation pairs - simplified implementation"""
+        return []
+
+    def _merge_concept_with_implementation(self, pair: Dict, content: str) -> Dict:
+        """Merge concepts with implementation - simplified implementation"""
+        return pair
+
+    def _detect_semantic_boundaries(self, content: str) -> List[Dict]:
+        """Detect semantic boundaries - based on paragraphs and logical separators"""
+        boundaries = []
+
+        # Split paragraphs by double line breaks
+        paragraphs = content.split("\n\n")
+        current_pos = 0
+
+        for i, para in enumerate(paragraphs):
+            if len(para.strip()) > 100:  # Valid paragraph
+                # Analyze paragraph type
+                content_type = self._classify_paragraph_type(para)
+                importance_score = self._calculate_paragraph_importance(
+                    para, content_type
+                )
+
+                boundaries.append(
+                    {
+                        "position": current_pos + len(para),
+                        "suggested_title": self._extract_paragraph_title(para, i + 1),
+                        "importance_score": importance_score,
+                        "content_type": content_type,
+                    }
+                )
+
+            current_pos += len(para) + 2  # +2 for \n\n
+
+        return boundaries
+
+    def _classify_paragraph_type(self, paragraph: str) -> str:
+        """Classify paragraph type"""
+        para_lower = paragraph.lower()
+
+        if "algorithm" in para_lower or "procedure" in para_lower:
+            return "algorithm"
+        elif "formula" in para_lower or "$$" in paragraph:
+            return "formula"
+        elif any(
+            word in para_lower for word in ["introduction", "overview", "abstract"]
+        ):
+            return "introduction"
+        elif any(word in para_lower for word in ["conclusion", "summary", "result"]):
+            return "conclusion"
+        else:
+            return "general"
+
+    def _calculate_paragraph_importance(
+        self, paragraph: str, content_type: str
+    ) -> float:
+        """Calculate paragraph importance"""
+        if content_type == "algorithm":
+            return 0.95
+        elif content_type == "formula":
+            return 0.9
+        elif content_type == "introduction":
+            return 0.85
+        elif content_type == "conclusion":
+            return 0.8
+        else:
+            return 0.7
+
+    def _extract_paragraph_title(self, paragraph: str, index: int) -> str:
+        """Extract paragraph title"""
+        lines = paragraph.split("\n")
+        for line in lines[:2]:
+            if line.startswith("#"):
+                return line.strip("# ")
+            elif len(line) < 80 and line.strip():
+                return line.strip()
+        return f"Section {index}"
+
+    def _calculate_optimal_chunk_size(self, content: str) -> int:
+        """Calculate optimal chunk size"""
+        # Dynamically adjust based on content complexity
+        complexity = self.analyzer._calculate_concept_complexity(content)
+        if complexity > 0.7:
+            return 4000  # Complex content needs larger chunks
+        elif complexity > 0.4:
+            return 3000
+        else:
+            return 2000
+
+    def _create_content_aware_chunks(self, content: str, chunk_size: int) -> List[Dict]:
+        """Create content-aware chunks - simplified implementation"""
+        chunks = []
+        paragraphs = [p.strip() for p in content.split("\n\n") if p.strip()]
+
+        current_chunk = []
+        current_size = 0
+        start_pos = 0
+
+        for para in paragraphs:
+            para_size = len(para)
+
+            if current_size + para_size > chunk_size and current_chunk:
+                chunk_content = "\n\n".join(current_chunk)
+                chunks.append(
+                    {
+                        "content": chunk_content,
+                        "title": f"Section {len(chunks) + 1}",
+                        "start_pos": start_pos,
+                        "end_pos": start_pos + len(chunk_content),
+                        "importance_score": 0.7,
+                        "content_type": "general",
+                    }
+                )
+
+                current_chunk = [para]
+                current_size = para_size
+                start_pos += len(chunk_content) + 2
+            else:
+                current_chunk.append(para)
+                current_size += para_size
+
+        # Add the last chunk
+        if current_chunk:
+            chunk_content = "\n\n".join(current_chunk)
+            chunks.append(
+                {
+                    "content": chunk_content,
+                    "title": f"Section {len(chunks) + 1}",
+                    "start_pos": start_pos,
+                    "end_pos": start_pos + len(chunk_content),
+                    "importance_score": 0.7,
+                    "content_type": "general",
+                }
+            )
+
+        return chunks
+
+    def _create_segment(
+        self, content: str, title: str, start_pos: int, end_pos: int
+    ) -> DocumentSegment:
+        """Create a DocumentSegment with metadata"""
+        # Generate unique ID
+        segment_id = hashlib.md5(f"{title}_{start_pos}_{end_pos}".encode()).hexdigest()[
+            :8
+        ]
+
+        # Extract keywords from content
+        keywords = self._extract_keywords(content)
+
+        # Determine content type
+        content_type = self._classify_content_type(title, content)
+
+        # Calculate relevance scores for different query types
+        relevance_scores = self._calculate_relevance_scores(content, content_type)
+
+        return DocumentSegment(
+            id=segment_id,
+            title=title,
+            content=content,
+            content_type=content_type,
+            keywords=keywords,
+            char_start=start_pos,
+            char_end=end_pos,
+            char_count=len(content),
+            relevance_scores=relevance_scores,
+            section_path=title,  # Simplified for now
+        )
+
+    def _extract_keywords(self, content: str) -> List[str]:
+        """Extract relevant keywords from content"""
+        # Simple keyword extraction - could be enhanced with NLP
+        words = re.findall(r"\b[a-zA-Z]{3,}\b", content.lower())
+
+        # Remove common words
+        stopwords = {
+            "the",
+            "and",
+            "for",
+            "are",
+            "but",
+            "not",
+            "you",
+            "all",
+            "can",
+            "her",
+            "was",
+            "one",
+            "our",
+            "had",
+            "but",
+            "have",
+            "this",
+            "that",
+            "with",
+            "from",
+            "they",
+            "she",
+            "been",
+            "were",
+            "said",
+            "each",
+            "which",
+            "their",
+        }
+
+        keywords = [w for w in set(words) if w not in stopwords and len(w) > 3]
+        return keywords[:20]  # Top 20 keywords
+
+    def _classify_content_type(self, title: str, content: str) -> str:
+        """Classify the type of content based on title and content"""
+        title_lower = title.lower()
+        content_lower = content.lower()
+
+        if any(
+            word in title_lower for word in ["introduction", "abstract", "overview"]
+        ):
+            return "introduction"
+        elif any(word in title_lower for word in ["method", "approach", "algorithm"]):
+            return "methodology"
+        elif any(
+            word in title_lower for word in ["experiment", "evaluation", "result"]
+        ):
+            return "experiment"
+        elif any(
+            word in title_lower for word in ["conclusion", "discussion", "summary"]
+        ):
+            return "conclusion"
+        elif any(word in title_lower for word in ["reference", "bibliography"]):
+            return "references"
+        elif "algorithm" in content_lower or "procedure" in content_lower:
+            return "algorithm"
+        else:
+            return "general"
+
+    def _calculate_relevance_scores(
+        self, content: str, content_type: str
+    ) -> Dict[str, float]:
+        """Calculate relevance scores for different query types"""
+        content_lower = content.lower()
+
+        scores = {
+            "concept_analysis": 0.5,
+            "algorithm_extraction": 0.5,
+            "code_planning": 0.5,
+        }
+
+        # Concept analysis relevance
+        concept_indicators = [
+            "introduction",
+            "overview",
+            "architecture",
+            "system",
+            "framework",
+            "concept",
+            "approach",
+        ]
+        concept_score = sum(
+            1 for indicator in concept_indicators if indicator in content_lower
+        ) / len(concept_indicators)
+        scores["concept_analysis"] = min(
+            1.0, concept_score + (0.8 if content_type == "introduction" else 0)
+        )
+
+        # Algorithm extraction relevance
+        algorithm_indicators = [
+            "algorithm",
+            "method",
+            "procedure",
+            "formula",
+            "equation",
+            "step",
+            "process",
+        ]
+        algorithm_score = sum(
+            1 for indicator in algorithm_indicators if indicator in content_lower
+        ) / len(algorithm_indicators)
+        scores["algorithm_extraction"] = min(
+            1.0, algorithm_score + (0.9 if content_type == "methodology" else 0)
+        )
+
+        # Code planning relevance
+        code_indicators = [
+            "implementation",
+            "code",
+            "function",
+            "class",
+            "module",
+            "structure",
+            "design",
+        ]
+        code_score = sum(
+            1 for indicator in code_indicators if indicator in content_lower
+        ) / len(code_indicators)
+        scores["code_planning"] = min(
+            1.0,
+            code_score + (0.7 if content_type in ["methodology", "algorithm"] else 0),
+        )
+
+        return scores
+
+
+# Global variables
+DOCUMENT_INDEXES: Dict[str, DocumentIndex] = {}
+segmenter = DocumentSegmenter()
+
+
+def get_segments_dir(paper_dir: str) -> str:
+    """Get the segments directory path"""
+    return os.path.join(paper_dir, "document_segments")
+
+
+def ensure_segments_dir_exists(segments_dir: str):
+    """Ensure segments directory exists"""
+    os.makedirs(segments_dir, exist_ok=True)
+
+
+@mcp.tool()
+async def analyze_and_segment_document(
+    paper_dir: str, force_refresh: bool = False
+) -> str:
+    """
+    Analyze document structure and create intelligent segments
+
+    Args:
+        paper_dir: Path to the paper directory
+        force_refresh: Whether to force re-analysis even if segments exist
+
+    Returns:
+        JSON string with segmentation results
+    """
+    try:
+        # Find markdown file in paper directory
+        md_files = [f for f in os.listdir(paper_dir) if f.endswith(".md")]
+        if not md_files:
+            return json.dumps(
+                {
+                    "status": "error",
+                    "message": f"No markdown file found in {paper_dir}",
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        md_file_path = os.path.join(paper_dir, md_files[0])
+        segments_dir = get_segments_dir(paper_dir)
+        index_file_path = os.path.join(segments_dir, "document_index.json")
+
+        # Check if analysis already exists and is recent
+        if not force_refresh and os.path.exists(index_file_path):
+            try:
+                with open(index_file_path, "r", encoding="utf-8") as f:
+                    existing_index = json.load(f)
+
+                    # Compatibility handling: ensure segments data structure is correct
+                    if "segments" in existing_index:
+                        segments_data = []
+                        for seg_data in existing_index["segments"]:
+                            # Ensure all required fields exist
+                            segment_dict = dict(seg_data)
+
+                            if "content_type" not in segment_dict:
+                                segment_dict["content_type"] = "general"
+                            if "keywords" not in segment_dict:
+                                segment_dict["keywords"] = []
+                            if "relevance_scores" not in segment_dict:
+                                segment_dict["relevance_scores"] = {
+                                    "concept_analysis": 0.5,
+                                    "algorithm_extraction": 0.5,
+                                    "code_planning": 0.5,
+                                }
+                            if "section_path" not in segment_dict:
+                                segment_dict["section_path"] = segment_dict.get(
+                                    "title", "Unknown"
+                                )
+
+                            segments_data.append(DocumentSegment(**segment_dict))
+
+                        existing_index["segments"] = segments_data
+
+                    DOCUMENT_INDEXES[paper_dir] = DocumentIndex(**existing_index)
+                return json.dumps(
+                    {
+                        "status": "success",
+                        "message": "Using existing document analysis",
+                        "segments_dir": segments_dir,
+                        "total_segments": existing_index["total_segments"],
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to load existing index: {e}")
+                logger.info("Will perform fresh analysis instead")
+                # Remove corrupted index file and continue with new analysis
+                try:
+                    os.remove(index_file_path)
+                except Exception as e:
+                    pass
+
+        # Read document content
+        with open(md_file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Analyze document
+        analyzer = DocumentAnalyzer()
+        doc_type, confidence = analyzer.analyze_document_type(content)
+        strategy = analyzer.detect_segmentation_strategy(content, doc_type)
+
+        # Create segments
+        segments = segmenter.segment_document(content, strategy)
+
+        # Create document index
+        document_index = DocumentIndex(
+            document_path=md_file_path,
+            document_type=doc_type,
+            segmentation_strategy=strategy,
+            total_segments=len(segments),
+            total_chars=len(content),
+            segments=segments,
+            created_at=datetime.now().isoformat(),
+        )
+
+        # Save segments
+        ensure_segments_dir_exists(segments_dir)
+
+        # Save document index
+        with open(index_file_path, "w", encoding="utf-8") as f:
+            json.dump(
+                asdict(document_index), f, ensure_ascii=False, indent=2, default=str
+            )
+
+        # Save individual segment files for fallback
+        for segment in segments:
+            segment_file_path = os.path.join(segments_dir, f"segment_{segment.id}.md")
+            with open(segment_file_path, "w", encoding="utf-8") as f:
+                f.write(f"# {segment.title}\n\n")
+                f.write(f"**Content Type:** {segment.content_type}\n")
+                f.write(f"**Keywords:** {', '.join(segment.keywords[:10])}\n\n")
+                f.write(segment.content)
+
+        # Store in memory
+        DOCUMENT_INDEXES[paper_dir] = document_index
+
+        logger.info(
+            f"Document segmentation completed: {len(segments)} segments created"
+        )
+
+        return json.dumps(
+            {
+                "status": "success",
+                "message": f"Document analysis completed with {strategy} strategy",
+                "document_type": doc_type,
+                "segmentation_strategy": strategy,
+                "segments_dir": segments_dir,
+                "total_segments": len(segments),
+                "total_chars": len(content),
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    except Exception as e:
+        logger.error(f"Error in analyze_and_segment_document: {e}")
+        return json.dumps(
+            {"status": "error", "message": f"Failed to analyze document: {str(e)}"},
+            ensure_ascii=False,
+            indent=2,
+        )
+
+
+@mcp.tool()
+async def read_document_segments(
+    paper_dir: str,
+    query_type: str,
+    keywords: List[str] = None,
+    max_segments: int = 3,
+    max_total_chars: int = None,
+) -> str:
+    """
+    Intelligently retrieve relevant document segments based on query type
+
+    Args:
+        paper_dir: Path to the paper directory
+        query_type: Type of query - "concept_analysis", "algorithm_extraction", or "code_planning"
+        keywords: Optional list of keywords to search for
+        max_segments: Maximum number of segments to return
+        max_total_chars: Maximum total characters to return
+
+    Returns:
+        JSON string with selected segments
+    """
+    try:
+        # Ensure document is analyzed
+        if paper_dir not in DOCUMENT_INDEXES:
+            segments_dir = get_segments_dir(paper_dir)
+            index_file_path = os.path.join(segments_dir, "document_index.json")
+
+            if os.path.exists(index_file_path):
+                with open(index_file_path, "r", encoding="utf-8") as f:
+                    index_data = json.load(f)
+                    # Convert dict back to DocumentIndex with backward compatibility
+                    segments_data = []
+                    for seg_data in index_data.get("segments", []):
+                        # Ensure all required fields exist, provide default values
+                        segment_dict = dict(seg_data)
+
+                        # Compatibility handling: add missing fields
+                        if "content_type" not in segment_dict:
+                            segment_dict["content_type"] = "general"
+                        if "keywords" not in segment_dict:
+                            segment_dict["keywords"] = []
+                        if "relevance_scores" not in segment_dict:
+                            segment_dict["relevance_scores"] = {
+                                "concept_analysis": 0.5,
+                                "algorithm_extraction": 0.5,
+                                "code_planning": 0.5,
+                            }
+                        if "section_path" not in segment_dict:
+                            segment_dict["section_path"] = segment_dict.get(
+                                "title", "Unknown"
+                            )
+
+                        segment = DocumentSegment(**segment_dict)
+                        segments_data.append(segment)
+
+                    index_data["segments"] = segments_data
+                    DOCUMENT_INDEXES[paper_dir] = DocumentIndex(**index_data)
+            else:
+                # Auto-analyze if not found
+                await analyze_and_segment_document(paper_dir)
+
+        document_index = DOCUMENT_INDEXES[paper_dir]
+
+        # Dynamically calculate character limit
+        if max_total_chars is None:
+            max_total_chars = _calculate_adaptive_char_limit(document_index, query_type)
+
+        # Score and rank segments with enhanced algorithm
+        scored_segments = []
+        for segment in document_index.segments:
+            # Base relevance score (already enhanced in new system)
+            relevance_score = segment.relevance_scores.get(query_type, 0.5)
+
+            # Enhanced keyword matching with position weighting
+            if keywords:
+                keyword_score = _calculate_enhanced_keyword_score(segment, keywords)
+                relevance_score += keyword_score
+
+            # Content completeness bonus
+            completeness_bonus = _calculate_completeness_bonus(segment, document_index)
+            relevance_score += completeness_bonus
+
+            scored_segments.append((segment, relevance_score))
+
+        # Sort by enhanced relevance score
+        scored_segments.sort(key=lambda x: x[1], reverse=True)
+
+        # Intelligent segment selection with integrity preservation
+        selected_segments = _select_segments_with_integrity(
+            scored_segments, max_segments, max_total_chars, query_type
+        )
+
+        total_chars = sum(seg["char_count"] for seg in selected_segments)
+
+        logger.info(
+            f"Selected {len(selected_segments)} segments for {query_type} query"
+        )
+
+        return json.dumps(
+            {
+                "status": "success",
+                "query_type": query_type,
+                "keywords": keywords or [],
+                "total_segments_available": len(document_index.segments),
+                "segments_selected": len(selected_segments),
+                "total_chars": total_chars,
+                "max_chars_used": max_total_chars,
+                "segments": selected_segments,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    except Exception as e:
+        logger.error(f"Error in read_document_segments: {e}")
+        return json.dumps(
+            {
+                "status": "error",
+                "message": f"Failed to read document segments: {str(e)}",
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+
+@mcp.tool()
+async def get_document_overview(paper_dir: str) -> str:
+    """
+    Get overview of document structure and available segments
+
+    Args:
+        paper_dir: Path to the paper directory
+
+    Returns:
+        JSON string with document overview
+    """
+    try:
+        # Ensure document is analyzed
+        if paper_dir not in DOCUMENT_INDEXES:
+            await analyze_and_segment_document(paper_dir)
+
+        document_index = DOCUMENT_INDEXES[paper_dir]
+
+        # Create overview
+        segment_summaries = []
+        for segment in document_index.segments:
+            segment_summaries.append(
+                {
+                    "id": segment.id,
+                    "title": segment.title,
+                    "content_type": segment.content_type,
+                    "char_count": segment.char_count,
+                    "keywords": segment.keywords[:5],  # Top 5 keywords
+                    "relevance_scores": segment.relevance_scores,
+                }
+            )
+
+        return json.dumps(
+            {
+                "status": "success",
+                "document_path": document_index.document_path,
+                "document_type": document_index.document_type,
+                "segmentation_strategy": document_index.segmentation_strategy,
+                "total_segments": document_index.total_segments,
+                "total_chars": document_index.total_chars,
+                "created_at": document_index.created_at,
+                "segments_overview": segment_summaries,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    except Exception as e:
+        logger.error(f"Error in get_document_overview: {e}")
+        return json.dumps(
+            {
+                "status": "error",
+                "message": f"Failed to get document overview: {str(e)}",
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+
+# =============== Enhanced retrieval system helper methods ===============
+
+
+def _calculate_adaptive_char_limit(
+    document_index: DocumentIndex, query_type: str
+) -> int:
+    """Dynamically calculate character limit based on document complexity and query type"""
+    base_limit = 6000
+
+    # Adjust based on document type
+    if document_index.document_type == "research_paper":
+        base_limit = 10000
+    elif document_index.document_type == "algorithm_focused":
+        base_limit = 12000
+    elif document_index.segmentation_strategy == "algorithm_preserve_integrity":
+        base_limit = 15000
+
+    # Adjust based on query type
+    query_multipliers = {
+        "algorithm_extraction": 1.5,  # Algorithms need more context
+        "concept_analysis": 1.2,
+        "code_planning": 1.3,
+    }
+
+    multiplier = query_multipliers.get(query_type, 1.0)
+    return int(base_limit * multiplier)
+
+
+def _calculate_enhanced_keyword_score(
+    segment: DocumentSegment, keywords: List[str]
+) -> float:
+    """Calculate enhanced keyword matching score"""
+    score = 0.0
+    content_lower = segment.content.lower()
+    title_lower = segment.title.lower()
+
+    for keyword in keywords:
+        keyword_lower = keyword.lower()
+
+        # Title matching has higher weight
+        if keyword_lower in title_lower:
+            score += 0.3
+
+        # Content matching
+        content_matches = content_lower.count(keyword_lower)
+        if content_matches > 0:
+            # Consider term frequency and position
+            frequency_score = min(0.2, content_matches * 0.05)
+
+            # Check if in important position (first 25% of content)
+            early_content = content_lower[: len(content_lower) // 4]
+            if keyword_lower in early_content:
+                frequency_score += 0.1
+
+            score += frequency_score
+
+    return min(0.6, score)  # Limit maximum bonus
+
+
+def _calculate_completeness_bonus(
+    segment: DocumentSegment, document_index: DocumentIndex
+) -> float:
+    """Calculate content completeness bonus"""
+    bonus = 0.0
+
+    # Completeness bonus for algorithm and formula content
+    if segment.content_type in ["algorithm", "formula", "merged"]:
+        bonus += 0.2
+
+    # Long paragraphs usually contain more complete information
+    if segment.char_count > 2000:
+        bonus += 0.1
+    elif segment.char_count > 4000:
+        bonus += 0.15
+
+    # High importance paragraph bonus
+    if segment.relevance_scores.get("algorithm_extraction", 0) > 0.8:
+        bonus += 0.1
+
+    return min(0.3, bonus)
+
+
+def _select_segments_with_integrity(
+    scored_segments: List[Tuple],
+    max_segments: int,
+    max_total_chars: int,
+    query_type: str,
+) -> List[Dict]:
+    """Intelligently select segments while maintaining content integrity"""
+    selected_segments = []
+    total_chars = 0
+
+    # First select the highest scoring segments
+    for segment, score in scored_segments:
+        if len(selected_segments) >= max_segments:
+            break
+
+        if total_chars + segment.char_count <= max_total_chars:
+            selected_segments.append(
+                {
+                    "id": segment.id,
+                    "title": segment.title,
+                    "content": segment.content,
+                    "content_type": segment.content_type,
+                    "relevance_score": score,
+                    "char_count": segment.char_count,
+                }
+            )
+            total_chars += segment.char_count
+        elif len(selected_segments) == 0:
+            # If the first segment exceeds the limit, truncate but preserve it
+            truncated_content = (
+                segment.content[: max_total_chars - 200]
+                + "\n\n[Content truncated for length...]"
+            )
+            selected_segments.append(
+                {
+                    "id": segment.id,
+                    "title": segment.title,
+                    "content": truncated_content,
+                    "content_type": segment.content_type,
+                    "relevance_score": score,
+                    "char_count": len(truncated_content),
+                }
+            )
+            break
+
+    # If there's remaining space, try to add relevant small segments
+    remaining_chars = max_total_chars - total_chars
+    if remaining_chars > 500 and len(selected_segments) < max_segments:
+        for segment, score in scored_segments[len(selected_segments) :]:
+            if (
+                segment.char_count <= remaining_chars
+                and len(selected_segments) < max_segments
+            ):
+                selected_segments.append(
+                    {
+                        "id": segment.id,
+                        "title": segment.title,
+                        "content": segment.content,
+                        "content_type": segment.content_type,
+                        "relevance_score": score,
+                        "char_count": segment.char_count,
+                    }
+                )
+                remaining_chars -= segment.char_count
+
+    return selected_segments
+
+
+if __name__ == "__main__":
+    # Run the MCP server
+    mcp.run()

projects/ui/DeepCode/tools/git_command.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+"""
+GitHub Repository Downloader MCP Tool using FastMCP
+"""
+
+import asyncio
+import os
+import re
+from typing import Dict, List, Optional
+from pathlib import Path
+
+from mcp.server import FastMCP
+
+# 创建 FastMCP 实例
+mcp = FastMCP("github-downloader")
+
+
+class GitHubURLExtractor:
+    """提取GitHub URL的工具类"""
+
+    @staticmethod
+    def extract_github_urls(text: str) -> List[str]:
+        """从文本中提取GitHub URLs"""
+        patterns = [
+            # 标准HTTPS URL
+            r"https?://github\.com/[\w\-\.]+/[\w\-\.]+(?:\.git)?",
+            # SSH URL
+            r"git@github\.com:[\w\-\.]+/[\w\-\.]+(?:\.git)?",
+            # 短格式 owner/repo - 更严格的匹配
+            r"(?<!\S)(?<!/)(?<!\.)([\w\-\.]+/[\w\-\.]+)(?!/)(?!\S)",
+        ]
+
+        urls = []
+        for pattern in patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            for match in matches:
+                # 处理短格式
+                if isinstance(match, tuple):
+                    match = match[0]
+
+                # 清理URL
+                if match.startswith("git@"):
+                    url = match.replace("git@github.com:", "https://github.com/")
+                elif match.startswith("http"):
+                    url = match
+                else:
+                    # 处理短格式 (owner/repo) - 添加更多验证
+                    if "/" in match and not any(
+                        x in match for x in ["./", "../", "deepcode_lab", "tools"]
+                    ):
+                        parts = match.split("/")
+                        if (
+                            len(parts) == 2
+                            and all(
+                                part.replace("-", "").replace("_", "").isalnum()
+                                for part in parts
+                            )
+                            and not any(part.startswith(".") for part in parts)
+                        ):
+                            url = f"https://github.com/{match}"
+                        else:
+                            continue
+                    else:
+                        continue
+
+                # 规范化 URL
+                url = url.rstrip(".git")
+                url = url.rstrip("/")
+
+                # 修复重复的 github.com
+                if "github.com/github.com/" in url:
+                    url = url.replace("github.com/github.com/", "github.com/")
+
+                urls.append(url)
+
+        return list(set(urls))  # 去重
+
+    @staticmethod
+    def extract_target_path(text: str) -> Optional[str]:
+        """从文本中提取目标路径"""
+        # 路径指示词模式
+        patterns = [
+            r'(?:to|into|in|at)\s+(?:folder|directory|path)?\s*["\']?([^\s"\']+)["\']?',
+            r'(?:save|download|clone)\s+(?:to|into|at)\s+["\']?([^\s"\']+)["\']?',
+            # 中文支持
+            r'(?:到|在|保存到|下载到|克隆到)\s*["\']?([^\s"\']+)["\']?',
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                path = match.group(1).strip("。，,.")
+                # 过滤掉通用词
+                if path and path.lower() not in [
+                    "here",
+                    "there",
+                    "current",
+                    "local",
+                    "这里",
+                    "当前",
+                    "本地",
+                ]:
+                    return path
+
+        return None
+
+    @staticmethod
+    def infer_repo_name(url: str) -> str:
+        """从URL推断仓库名称"""
+        url = url.rstrip(".git")
+        if "github.com" in url:
+            parts = url.split("/")
+            if len(parts) >= 2:
+                return parts[-1]
+        return "repository"
+
+
+async def check_git_installed() -> bool:
+    """检查Git是否安装"""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "--version",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.wait()
+        return proc.returncode == 0
+    except Exception:
+        return False
+
+
+async def clone_repository(repo_url: str, target_path: str) -> Dict[str, any]:
+    """执行git clone命令"""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "clone",
+            repo_url,
+            target_path,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        stdout, stderr = await proc.communicate()
+
+        return {
+            "success": proc.returncode == 0,
+            "stdout": stdout.decode("utf-8", errors="replace"),
+            "stderr": stderr.decode("utf-8", errors="replace"),
+            "returncode": proc.returncode,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+async def download_github_repo(instruction: str) -> str:
+    """
+    Download GitHub repositories from natural language instructions.
+
+    Args:
+        instruction: Natural language text containing GitHub URLs and optional target paths
+
+    Returns:
+        Status message about the download operation
+
+    Examples:
+        - "Download https://github.com/openai/gpt-3"
+        - "Clone microsoft/vscode to my-projects folder"
+        - "Get https://github.com/facebook/react"
+    """
+    # 检查Git是否安装
+    if not await check_git_installed():
+        return "❌ Error: Git is not installed or not in system PATH"
+
+    extractor = GitHubURLExtractor()
+
+    # 提取GitHub URLs
+    urls = extractor.extract_github_urls(instruction)
+    if not urls:
+        return "❌ No GitHub URLs found in the instruction"
+
+    # 提取目标路径
+    target_path = extractor.extract_target_path(instruction)
+
+    # 下载仓库
+    results = []
+    for url in urls:
+        try:
+            # 准备目标路径
+            if target_path:
+                # 判断是否为绝对路径
+                if os.path.isabs(target_path):
+                    # 如果是绝对路径，直接使用
+                    final_path = target_path
+                    # 如果目标路径是目录，添加仓库名
+                    if os.path.basename(target_path) == "" or target_path.endswith("/"):
+                        final_path = os.path.join(
+                            target_path, extractor.infer_repo_name(url)
+                        )
+                else:
+                    # 如果是相对路径，保持相对路径
+                    final_path = target_path
+                    # 如果目标路径是目录，添加仓库名
+                    if os.path.basename(target_path) == "" or target_path.endswith("/"):
+                        final_path = os.path.join(
+                            target_path, extractor.infer_repo_name(url)
+                        )
+            else:
+                final_path = extractor.infer_repo_name(url)
+
+            # 如果是相对路径，确保使用相对路径格式
+            if not os.path.isabs(final_path):
+                final_path = os.path.normpath(final_path)
+                if final_path.startswith("/"):
+                    final_path = final_path.lstrip("/")
+
+            # 确保父目录存在
+            parent_dir = os.path.dirname(final_path)
+            if parent_dir:
+                os.makedirs(parent_dir, exist_ok=True)
+
+            # 检查目标路径是否已存在
+            if os.path.exists(final_path):
+                results.append(
+                    f"❌ Failed to download {url}: Target path already exists: {final_path}"
+                )
+                continue
+
+            # 执行克隆
+            result = await clone_repository(url, final_path)
+
+            if result["success"]:
+                msg = f"✅ Successfully downloaded: {url}\n"
+                msg += f"   Location: {final_path}"
+                if result.get("stdout"):
+                    msg += f"\n   {result['stdout'].strip()}"
+            else:
+                msg = f"❌ Failed to download: {url}\n"
+                msg += f"   Error: {result.get('error', result.get('stderr', 'Unknown error'))}"
+
+        except Exception as e:
+            msg = f"❌ Failed to download: {url}\n"
+            msg += f"   Error: {str(e)}"
+
+        results.append(msg)
+
+    return "\n\n".join(results)
+
+
+@mcp.tool()
+async def parse_github_urls(text: str) -> str:
+    """
+    Extract GitHub URLs and target paths from text.
+
+    Args:
+        text: Text containing GitHub URLs
+
+    Returns:
+        Parsed GitHub URLs and target path information
+    """
+    extractor = GitHubURLExtractor()
+
+    urls = extractor.extract_github_urls(text)
+    target_path = extractor.extract_target_path(text)
+
+    content = "📝 Parsed information:\n\n"
+
+    if urls:
+        content += "GitHub URLs found:\n"
+        for url in urls:
+            content += f"  • {url}\n"
+    else:
+        content += "No GitHub URLs found\n"
+
+    if target_path:
+        content += f"\nTarget path: {target_path}"
+    else:
+        content += "\nTarget path: Not specified (will use repository name)"
+
+    return content
+
+
+@mcp.tool()
+async def git_clone(
+    repo_url: str, target_path: Optional[str] = None, branch: Optional[str] = None
+) -> str:
+    """
+    Clone a specific GitHub repository.
+
+    Args:
+        repo_url: GitHub repository URL
+        target_path: Optional target directory path
+        branch: Optional branch name to clone
+
+    Returns:
+        Status message about the clone operation
+    """
+    # 检查Git是否安装
+    if not await check_git_installed():
+        return "❌ Error: Git is not installed or not in system PATH"
+
+    # 准备目标路径
+    if not target_path:
+        extractor = GitHubURLExtractor()
+        target_path = extractor.infer_repo_name(repo_url)
+
+    # 转换���绝对路径
+    if not os.path.isabs(target_path):
+        target_path = str(Path.cwd() / target_path)
+
+    # 检查目标路径
+    if os.path.exists(target_path):
+        return f"❌ Error: Target path already exists: {target_path}"
+
+    # 构建命令
+    cmd = ["git", "clone"]
+    if branch:
+        cmd.extend(["-b", branch])
+    cmd.extend([repo_url, target_path])
+
+    # 执行克隆
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+
+        stdout, stderr = await proc.communicate()
+
+        if proc.returncode == 0:
+            result = "✅ Successfully cloned repository\n"
+            result += f"Repository: {repo_url}\n"
+            result += f"Location: {target_path}"
+            if branch:
+                result += f"\nBranch: {branch}"
+            return result
+        else:
+            return f"❌ Clone failed\nError: {stderr.decode('utf-8', errors='replace')}"
+
+    except Exception as e:
+        return f"❌ Clone failed\nError: {str(e)}"
+
+
+# 主程序入口
+if __name__ == "__main__":
+    print("🚀 GitHub Repository Downloader MCP Tool")
+    print("📝 Starting server with FastMCP...")
+    print("\nAvailable tools:")
+    print("  • download_github_repo - Download repos from natural language")
+    print("  • parse_github_urls - Extract GitHub URLs from text")
+    print("  • git_clone - Clone a specific repository")
+    print("")
+
+    # 运行服务器
+    mcp.run()

projects/ui/DeepCode/tools/indexer_config.yaml

@@ -0,0 +1,141 @@
+# Code Indexer Configuration File
+# Configure various aspects of the code indexing process
+
+# Paths Configuration
+paths:
+  code_base_path: "D:/Documents/GitHub/Code-Agent/examples/input/paper1/code_base"
+  output_dir: "D:/Documents/GitHub/Code-Agent/examples/input/paper1/indexes"
+
+# File Analysis Settings
+file_analysis:
+  # Supported file extensions for analysis
+  supported_extensions:
+    - ".py"      # Python
+    - ".js"      # JavaScript
+    - ".ts"      # TypeScript
+    - ".java"    # Java
+    - ".cpp"     # C++
+    - ".c"       # C
+    - ".h"       # C Header
+    - ".hpp"     # C++ Header
+    - ".cs"      # C#
+    - ".php"     # PHP
+    - ".rb"      # Ruby
+    - ".go"      # Go
+    - ".rs"      # Rust
+    - ".scala"   # Scala
+    - ".kt"      # Kotlin
+    - ".swift"   # Swift
+    - ".r"       # R
+    - ".sql"     # SQL
+    - ".sh"      # Shell Script
+    - ".bat"     # Batch File
+    - ".ps1"     # PowerShell
+    - ".yaml"    # YAML
+    - ".yml"     # YAML
+    - ".json"    # JSON
+    - ".xml"     # XML
+    - ".toml"    # TOML
+
+  # Directories to skip during traversal
+  skip_directories:
+    - "__pycache__"
+    - "node_modules"
+    - "target"
+    - "build"
+    - "dist"
+    - "venv"
+    - "env"
+    - ".git"
+    - ".svn"
+    - ".hg"
+    - "coverage"
+    - ".pytest_cache"
+    - ".mypy_cache"
+
+  # Maximum file size to analyze (in bytes)
+  max_file_size: 1048576  # 1MB
+
+  # Maximum content length to send to LLM (in characters)
+  max_content_length: 3000
+
+# LLM Configuration
+llm:
+  # Model selection: "anthropic" or "openai"
+  model_provider: "openai"
+
+  # Request parameters
+  max_tokens: 4000
+  temperature: 0.3
+
+  # System prompt for analysis
+  system_prompt: "You are a code analysis expert. Provide precise, structured analysis of code relationships and similarities."
+
+  # Rate limiting (seconds between requests)
+  request_delay: 0.1
+
+  # Retry configuration
+  max_retries: 3
+  retry_delay: 1.0
+
+# Relationship Analysis Settings
+relationships:
+  # Minimum confidence score to include a relationship
+  min_confidence_score: 0.3
+
+  # High confidence threshold for reporting
+  high_confidence_threshold: 0.7
+
+  # Relationship types and their priorities
+  relationship_types:
+    direct_match: 1.0      # Direct implementation match
+    partial_match: 0.8     # Partial functionality match
+    reference: 0.6         # Reference or utility function
+    utility: 0.4           # General utility or helper
+
+# Output Configuration
+output:
+  # JSON formatting options
+  json_indent: 2
+  ensure_ascii: false
+
+  # Generate additional report files
+  generate_summary: true
+  generate_statistics: true
+
+  # Include metadata in output
+  include_metadata: true
+
+  # File naming pattern (use {repo_name} placeholder)
+  index_filename_pattern: "{repo_name}_index.json"
+  summary_filename: "indexing_summary.json"
+  stats_filename: "indexing_statistics.json"
+
+# Logging Configuration
+logging:
+  level: "INFO"  # DEBUG, INFO, WARNING, ERROR
+  log_to_file: true
+  log_file: "indexer.log"
+  log_format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+# Performance Settings
+performance:
+  # Enable concurrent processing of files within a repository
+  enable_concurrent_analysis: true
+  max_concurrent_files: 5
+
+  # Memory optimization
+  enable_content_caching: false
+  max_cache_size: 100
+
+# Debug and Development Settings
+debug:
+  # Save raw LLM responses for debugging
+  save_raw_responses: false
+  raw_responses_dir: "debug_responses"
+
+  # Verbose output during processing
+  verbose_output: false
+
+  # Skip LLM calls for testing (uses mock responses)
+  mock_llm_responses: false