Add files using upload-large-folder tool

projects/ui/DeepCode/tools/pdf_converter.py

@@ -0,0 +1,640 @@
+#!/usr/bin/env python3
+"""
+PDF Converter Utility
+
+This module provides functionality for converting various document formats to PDF,
+including Office documents (.doc, .docx, .ppt, .pptx, .xls, .xlsx) and text files (.txt, .md).
+
+Requirements:
+- LibreOffice for Office document conversion
+- ReportLab for text-to-PDF conversion
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import subprocess
+import tempfile
+import shutil
+import platform
+from pathlib import Path
+from typing import Union, Optional, Dict, Any
+
+
+class PDFConverter:
+    """
+    PDF conversion utility class.
+
+    Provides methods to convert Office documents and text files to PDF format.
+    """
+
+    # Define supported file formats
+    OFFICE_FORMATS = {".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx"}
+    TEXT_FORMATS = {".txt", ".md"}
+
+    # Class-level logger
+    logger = logging.getLogger(__name__)
+
+    def __init__(self) -> None:
+        """Initialize the PDF converter."""
+        pass
+
+    @staticmethod
+    def convert_office_to_pdf(
+        doc_path: Union[str, Path], output_dir: Optional[str] = None
+    ) -> Path:
+        """
+        Convert Office document (.doc, .docx, .ppt, .pptx, .xls, .xlsx) to PDF.
+        Requires LibreOffice to be installed.
+
+        Args:
+            doc_path: Path to the Office document file
+            output_dir: Output directory for the PDF file
+
+        Returns:
+            Path to the generated PDF file
+        """
+        try:
+            # Convert to Path object for easier handling
+            doc_path = Path(doc_path)
+            if not doc_path.exists():
+                raise FileNotFoundError(f"Office document does not exist: {doc_path}")
+
+            name_without_suff = doc_path.stem
+
+            # Prepare output directory
+            if output_dir:
+                base_output_dir = Path(output_dir)
+            else:
+                base_output_dir = doc_path.parent / "pdf_output"
+
+            base_output_dir.mkdir(parents=True, exist_ok=True)
+
+            # Check if LibreOffice is available
+            libreoffice_available = False
+            working_libreoffice_cmd: Optional[str] = None
+
+            # Prepare subprocess parameters to hide console window on Windows
+            subprocess_kwargs: Dict[str, Any] = {
+                "capture_output": True,
+                "check": True,
+                "timeout": 10,
+                "encoding": "utf-8",
+                "errors": "ignore",
+            }
+
+            # Hide console window on Windows
+            if platform.system() == "Windows":
+                subprocess_kwargs["creationflags"] = (
+                    0x08000000  # subprocess.CREATE_NO_WINDOW
+                )
+
+            try:
+                result = subprocess.run(
+                    ["libreoffice", "--version"], **subprocess_kwargs
+                )
+                libreoffice_available = True
+                working_libreoffice_cmd = "libreoffice"
+                logging.info(f"LibreOffice detected: {result.stdout.strip()}")  # type: ignore
+            except (
+                subprocess.CalledProcessError,
+                FileNotFoundError,
+                subprocess.TimeoutExpired,
+            ):
+                pass
+
+            # Try alternative commands for LibreOffice
+            if not libreoffice_available:
+                for cmd in ["soffice", "libreoffice"]:
+                    try:
+                        result = subprocess.run([cmd, "--version"], **subprocess_kwargs)
+                        libreoffice_available = True
+                        working_libreoffice_cmd = cmd
+                        logging.info(
+                            f"LibreOffice detected with command '{cmd}': {result.stdout.strip()}"  # type: ignore
+                        )
+                        break
+                    except (
+                        subprocess.CalledProcessError,
+                        FileNotFoundError,
+                        subprocess.TimeoutExpired,
+                    ):
+                        continue
+
+            if not libreoffice_available:
+                raise RuntimeError(
+                    "LibreOffice is required for Office document conversion but was not found.\n"
+                    "Please install LibreOffice:\n"
+                    "- Windows: Download from https://www.libreoffice.org/download/download/\n"
+                    "- macOS: brew install --cask libreoffice\n"
+                    "- Ubuntu/Debian: sudo apt-get install libreoffice\n"
+                    "- CentOS/RHEL: sudo yum install libreoffice\n"
+                    "Alternatively, convert the document to PDF manually."
+                )
+
+            # Create temporary directory for PDF conversion
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir)
+
+                # Convert to PDF using LibreOffice
+                logging.info(f"Converting {doc_path.name} to PDF using LibreOffice...")
+
+                # Use the working LibreOffice command first, then try alternatives if it fails
+                commands_to_try = [working_libreoffice_cmd]
+                if working_libreoffice_cmd == "libreoffice":
+                    commands_to_try.append("soffice")
+                else:
+                    commands_to_try.append("libreoffice")
+
+                conversion_successful = False
+                for cmd in commands_to_try:
+                    if cmd is None:
+                        continue
+                    try:
+                        convert_cmd = [
+                            cmd,
+                            "--headless",
+                            "--convert-to",
+                            "pdf",
+                            "--outdir",
+                            str(temp_path),
+                            str(doc_path),
+                        ]
+
+                        # Prepare conversion subprocess parameters
+                        convert_subprocess_kwargs: Dict[str, Any] = {
+                            "capture_output": True,
+                            "text": True,
+                            "timeout": 60,  # 60 second timeout
+                            "encoding": "utf-8",
+                            "errors": "ignore",
+                        }
+
+                        # Hide console window on Windows
+                        if platform.system() == "Windows":
+                            convert_subprocess_kwargs["creationflags"] = (
+                                0x08000000  # subprocess.CREATE_NO_WINDOW
+                            )
+
+                        result = subprocess.run(
+                            convert_cmd, **convert_subprocess_kwargs
+                        )
+
+                        if result.returncode == 0:  # type: ignore
+                            conversion_successful = True
+                            logging.info(
+                                f"Successfully converted {doc_path.name} to PDF"
+                            )
+                            break
+                        else:
+                            logging.warning(
+                                f"LibreOffice command '{cmd}' failed: {result.stderr}"  # type: ignore
+                            )
+                    except subprocess.TimeoutExpired:
+                        logging.warning(f"LibreOffice command '{cmd}' timed out")
+                    except Exception as e:
+                        logging.error(
+                            f"LibreOffice command '{cmd}' failed with exception: {e}"
+                        )
+
+                if not conversion_successful:
+                    raise RuntimeError(
+                        f"LibreOffice conversion failed for {doc_path.name}. "
+                        f"Please check if the file is corrupted or try converting manually."
+                    )
+
+                # Find the generated PDF
+                pdf_files = list(temp_path.glob("*.pdf"))
+                if not pdf_files:
+                    raise RuntimeError(
+                        f"PDF conversion failed for {doc_path.name} - no PDF file generated. "
+                        f"Please check LibreOffice installation or try manual conversion."
+                    )
+
+                pdf_path = pdf_files[0]
+                logging.info(
+                    f"Generated PDF: {pdf_path.name} ({pdf_path.stat().st_size} bytes)"
+                )
+
+                # Validate the generated PDF
+                if pdf_path.stat().st_size < 100:  # Very small file, likely empty
+                    raise RuntimeError(
+                        "Generated PDF appears to be empty or corrupted. "
+                        "Original file may have issues or LibreOffice conversion failed."
+                    )
+
+                # Copy PDF to final output directory
+                final_pdf_path = base_output_dir / f"{name_without_suff}.pdf"
+                shutil.copy2(pdf_path, final_pdf_path)
+
+                return final_pdf_path
+
+        except Exception as e:
+            logging.error(f"Error in convert_office_to_pdf: {str(e)}")
+            raise
+
+    @staticmethod
+    def convert_text_to_pdf(
+        text_path: Union[str, Path], output_dir: Optional[str] = None
+    ) -> Path:
+        """
+        Convert text file (.txt, .md) to PDF using ReportLab with full markdown support.
+
+        Args:
+            text_path: Path to the text file
+            output_dir: Output directory for the PDF file
+
+        Returns:
+            Path to the generated PDF file
+        """
+        try:
+            text_path = Path(text_path)
+            if not text_path.exists():
+                raise FileNotFoundError(f"Text file does not exist: {text_path}")
+
+            # Supported text formats
+            supported_text_formats = {".txt", ".md"}
+            if text_path.suffix.lower() not in supported_text_formats:
+                raise ValueError(f"Unsupported text format: {text_path.suffix}")
+
+            # Read the text content
+            try:
+                with open(text_path, "r", encoding="utf-8") as f:
+                    text_content = f.read()
+            except UnicodeDecodeError:
+                # Try with different encodings
+                for encoding in ["gbk", "latin-1", "cp1252"]:
+                    try:
+                        with open(text_path, "r", encoding=encoding) as f:
+                            text_content = f.read()
+                        logging.info(f"Successfully read file with {encoding} encoding")
+                        break
+                    except UnicodeDecodeError:
+                        continue
+                else:
+                    raise RuntimeError(
+                        f"Could not decode text file {text_path.name} with any supported encoding"
+                    )
+
+            # Prepare output directory
+            if output_dir:
+                base_output_dir = Path(output_dir)
+            else:
+                base_output_dir = text_path.parent / "pdf_output"
+
+            base_output_dir.mkdir(parents=True, exist_ok=True)
+            pdf_path = base_output_dir / f"{text_path.stem}.pdf"
+
+            # Convert text to PDF
+            logging.info(f"Converting {text_path.name} to PDF...")
+
+            try:
+                from reportlab.lib.pagesizes import A4
+                from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+                from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+                from reportlab.lib.units import inch
+                from reportlab.pdfbase import pdfmetrics
+
+                # Create PDF document
+                doc = SimpleDocTemplate(
+                    str(pdf_path),
+                    pagesize=A4,
+                    leftMargin=inch,
+                    rightMargin=inch,
+                    topMargin=inch,
+                    bottomMargin=inch,
+                )
+
+                # Get styles
+                styles = getSampleStyleSheet()
+                normal_style = styles["Normal"]
+                heading_style = styles["Heading1"]
+
+                # Try to register a font that supports Chinese characters
+                try:
+                    # Try to use system fonts that support Chinese
+                    system = platform.system()
+                    if system == "Windows":
+                        # Try common Windows fonts
+                        for font_name in ["SimSun", "SimHei", "Microsoft YaHei"]:
+                            try:
+                                from reportlab.pdfbase.cidfonts import (
+                                    UnicodeCIDFont,
+                                )
+
+                                pdfmetrics.registerFont(UnicodeCIDFont(font_name))  # type: ignore
+                                normal_style.fontName = font_name
+                                heading_style.fontName = font_name
+                                break
+                            except Exception:
+                                continue
+                    elif system == "Darwin":  # macOS
+                        for font_name in ["STSong-Light", "STHeiti"]:
+                            try:
+                                from reportlab.pdfbase.cidfonts import (
+                                    UnicodeCIDFont,
+                                )
+
+                                pdfmetrics.registerFont(UnicodeCIDFont(font_name))  # type: ignore
+                                normal_style.fontName = font_name
+                                heading_style.fontName = font_name
+                                break
+                            except Exception:
+                                continue
+                except Exception:
+                    pass  # Use default fonts if Chinese font setup fails
+
+                # Build content
+                story = []
+
+                # Handle markdown or plain text
+                if text_path.suffix.lower() == ".md":
+                    # Handle markdown content - simplified implementation
+                    lines = text_content.split("\n")
+                    for line in lines:
+                        line = line.strip()
+                        if not line:
+                            story.append(Spacer(1, 12))
+                            continue
+
+                        # Headers
+                        if line.startswith("#"):
+                            level = len(line) - len(line.lstrip("#"))
+                            header_text = line.lstrip("#").strip()
+                            if header_text:
+                                header_style = ParagraphStyle(
+                                    name=f"Heading{level}",
+                                    parent=heading_style,
+                                    fontSize=max(16 - level, 10),
+                                    spaceAfter=8,
+                                    spaceBefore=16 if level <= 2 else 12,
+                                )
+                                story.append(Paragraph(header_text, header_style))
+                        else:
+                            # Regular text
+                            processed_line = PDFConverter._process_inline_markdown(line)
+                            story.append(Paragraph(processed_line, normal_style))
+                            story.append(Spacer(1, 6))
+                else:
+                    # Handle plain text files (.txt)
+                    logging.info(
+                        f"Processing plain text file with {len(text_content)} characters..."
+                    )
+
+                    # Split text into lines and process each line
+                    lines = text_content.split("\n")
+                    line_count = 0
+
+                    for line in lines:
+                        line = line.rstrip()
+                        line_count += 1
+
+                        # Empty lines
+                        if not line.strip():
+                            story.append(Spacer(1, 6))
+                            continue
+
+                        # Regular text lines
+                        # Escape special characters for ReportLab
+                        safe_line = (
+                            line.replace("&", "&amp;")
+                            .replace("<", "&lt;")
+                            .replace(">", "&gt;")
+                        )
+
+                        # Create paragraph
+                        story.append(Paragraph(safe_line, normal_style))
+                        story.append(Spacer(1, 3))
+
+                    logging.info(f"Added {line_count} lines to PDF")
+
+                    # If no content was added, add a placeholder
+                    if not story:
+                        story.append(Paragraph("(Empty text file)", normal_style))
+
+                # Build PDF
+                doc.build(story)
+                logging.info(
+                    f"Successfully converted {text_path.name} to PDF ({pdf_path.stat().st_size / 1024:.1f} KB)"
+                )
+
+            except ImportError:
+                raise RuntimeError(
+                    "reportlab is required for text-to-PDF conversion. "
+                    "Please install it using: pip install reportlab"
+                )
+            except Exception as e:
+                raise RuntimeError(
+                    f"Failed to convert text file {text_path.name} to PDF: {str(e)}"
+                )
+
+            # Validate the generated PDF
+            if not pdf_path.exists() or pdf_path.stat().st_size < 100:
+                raise RuntimeError(
+                    f"PDF conversion failed for {text_path.name} - generated PDF is empty or corrupted."
+                )
+
+            return pdf_path
+
+        except Exception as e:
+            logging.error(f"Error in convert_text_to_pdf: {str(e)}")
+            raise
+
+    @staticmethod
+    def _process_inline_markdown(text: str) -> str:
+        """
+        Process inline markdown formatting (bold, italic, code, links)
+
+        Args:
+            text: Raw text with markdown formatting
+
+        Returns:
+            Text with ReportLab markup
+        """
+        import re
+
+        # Escape special characters for ReportLab
+        text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+        # Bold text: **text** or __text__
+        text = re.sub(r"\*\*(.*?)\*\*", r"<b>\1</b>", text)
+        text = re.sub(r"__(.*?)__", r"<b>\1</b>", text)
+
+        # Italic text: *text* or _text_ (but not in the middle of words)
+        text = re.sub(r"(?<!\w)\*([^*\n]+?)\*(?!\w)", r"<i>\1</i>", text)
+        text = re.sub(r"(?<!\w)_([^_\n]+?)_(?!\w)", r"<i>\1</i>", text)
+
+        # Inline code: `code`
+        text = re.sub(
+            r"`([^`]+?)`",
+            r'<font name="Courier" size="9" color="darkred">\1</font>',
+            text,
+        )
+
+        # Links: [text](url) - convert to text with URL annotation
+        def link_replacer(match):
+            link_text = match.group(1)
+            url = match.group(2)
+            return f'<link href="{url}" color="blue"><u>{link_text}</u></link>'
+
+        text = re.sub(r"\[([^\]]+?)\]\(([^)]+?)\)", link_replacer, text)
+
+        # Strikethrough: ~~text~~
+        text = re.sub(r"~~(.*?)~~", r"<strike>\1</strike>", text)
+
+        return text
+
+    def convert_to_pdf(
+        self,
+        file_path: Union[str, Path],
+        output_dir: Optional[str] = None,
+    ) -> Path:
+        """
+        Convert document to PDF based on file extension
+
+        Args:
+            file_path: Path to the file to be converted
+            output_dir: Output directory path
+
+        Returns:
+            Path to the generated PDF file
+        """
+        # Convert to Path object
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"File does not exist: {file_path}")
+
+        # Get file extension
+        ext = file_path.suffix.lower()
+
+        # Choose appropriate conversion method based on file type
+        if ext in self.OFFICE_FORMATS:
+            return self.convert_office_to_pdf(file_path, output_dir)
+        elif ext in self.TEXT_FORMATS:
+            return self.convert_text_to_pdf(file_path, output_dir)
+        else:
+            raise ValueError(
+                f"Unsupported file format: {ext}. "
+                f"Supported formats: {', '.join(self.OFFICE_FORMATS | self.TEXT_FORMATS)}"
+            )
+
+    def check_dependencies(self) -> dict:
+        """
+        Check if required dependencies are available
+
+        Returns:
+            dict: Dictionary with dependency check results
+        """
+        results = {
+            "libreoffice": False,
+            "reportlab": False,
+        }
+
+        # Check LibreOffice
+        try:
+            subprocess_kwargs: Dict[str, Any] = {
+                "capture_output": True,
+                "text": True,
+                "check": True,
+                "encoding": "utf-8",
+                "errors": "ignore",
+            }
+
+            if platform.system() == "Windows":
+                subprocess_kwargs["creationflags"] = (
+                    0x08000000  # subprocess.CREATE_NO_WINDOW
+                )
+
+            subprocess.run(["libreoffice", "--version"], **subprocess_kwargs)
+            results["libreoffice"] = True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            try:
+                subprocess.run(["soffice", "--version"], **subprocess_kwargs)
+                results["libreoffice"] = True
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                pass
+
+        # Check ReportLab
+        import importlib.util
+
+        if importlib.util.find_spec("reportlab") is not None:
+            results["reportlab"] = True
+
+        return results
+
+
+def main():
+    """
+    Main function to run the PDF converter from command line
+    """
+    parser = argparse.ArgumentParser(description="Convert documents to PDF format")
+    parser.add_argument("file_path", nargs="?", help="Path to the document to convert")
+    parser.add_argument("--output", "-o", help="Output directory path")
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Check dependencies installation",
+    )
+    parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Enable verbose logging"
+    )
+
+    args = parser.parse_args()
+
+    # Configure logging
+    log_level = logging.INFO if args.verbose else logging.WARNING
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # Initialize converter
+    converter = PDFConverter()
+
+    # Check dependencies if requested
+    if args.check:
+        print("🔍 Checking dependencies...")
+        deps = converter.check_dependencies()
+
+        print(
+            f"LibreOffice: {'✅ Available' if deps['libreoffice'] else '❌ Not found'}"
+        )
+        print(f"ReportLab: {'✅ Available' if deps['reportlab'] else '❌ Not found'}")
+
+        if not deps["libreoffice"]:
+            print("\n📋 To install LibreOffice:")
+            print("  - Windows: Download from https://www.libreoffice.org/")
+            print("  - macOS: brew install --cask libreoffice")
+            print("  - Ubuntu/Debian: sudo apt-get install libreoffice")
+
+        if not deps["reportlab"]:
+            print("\n📋 To install ReportLab:")
+            print("  pip install reportlab")
+
+        return 0
+
+    # If not checking dependencies, file_path is required
+    if not args.file_path:
+        parser.error("file_path is required when not using --check")
+
+    try:
+        # Convert the file
+        output_pdf = converter.convert_to_pdf(
+            file_path=args.file_path,
+            output_dir=args.output,
+        )
+
+        print(f"✅ Successfully converted to PDF: {output_pdf}")
+        print(f"📄 File size: {output_pdf.stat().st_size / 1024:.1f} KB")
+
+    except Exception as e:
+        print(f"❌ Error: {str(e)}")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

projects/ui/DeepCode/tools/pdf_downloader.py

@@ -0,0 +1,1379 @@
+#!/usr/bin/env python3
+"""
+Smart PDF Downloader MCP Tool
+
+A standardized MCP tool using FastMCP for intelligent file downloading and document conversion.
+Supports natural language instructions for downloading files from URLs, moving local files,
+and automatic conversion to Markdown format with image extraction.
+
+Features:
+- Natural language instruction parsing
+- URL and local path extraction
+- Automatic document conversion (PDF, DOCX, PPTX, HTML, etc.)
+- Image extraction and preservation
+- Multi-format support with fallback options
+"""
+
+import os
+import re
+import aiohttp
+import aiofiles
+import shutil
+import sys
+import io
+from typing import List, Dict, Optional, Any
+from urllib.parse import urlparse, unquote
+from datetime import datetime
+
+from mcp.server import FastMCP
+
+# Docling imports for document conversion
+try:
+    from docling.document_converter import DocumentConverter
+    from docling.datamodel.base_models import InputFormat
+    from docling.datamodel.pipeline_options import PdfPipelineOptions
+    from docling.document_converter import PdfFormatOption
+
+    DOCLING_AVAILABLE = True
+except ImportError:
+    DOCLING_AVAILABLE = False
+    print(
+        "Warning: docling package not available. Document conversion will be disabled."
+    )
+
+# Fallback PDF text extraction
+try:
+    import PyPDF2
+
+    PYPDF2_AVAILABLE = True
+except ImportError:
+    PYPDF2_AVAILABLE = False
+    print(
+        "Warning: PyPDF2 package not available. Fallback PDF extraction will be disabled."
+    )
+
+# 设置标准输出编码为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}")
+
+# 创建 FastMCP 实例
+mcp = FastMCP("smart-pdf-downloader")
+
+
+# 辅助函数
+def format_success_message(action: str, details: Dict[str, Any]) -> str:
+    """格式化成功消息"""
+    return f"✅ {action}\n" + "\n".join(f"   {k}: {v}" for k, v in details.items())
+
+
+def format_error_message(action: str, error: str) -> str:
+    """格式化错误消息"""
+    return f"❌ {action}\n   Error: {error}"
+
+
+def format_warning_message(action: str, warning: str) -> str:
+    """格式化警告消息"""
+    return f"⚠️ {action}\n   Warning: {warning}"
+
+
+async def perform_document_conversion(
+    file_path: str, extract_images: bool = True
+) -> Optional[str]:
+    """
+    执行文档转换的共用逻辑
+
+    Args:
+        file_path: 文件路径
+        extract_images: 是否提取图片
+
+    Returns:
+        转换信息字符串，如果没有转换则返回None
+    """
+    if not file_path:
+        return None
+
+    conversion_msg = ""
+
+    # 首先尝试使用简单的PDF转换器（对于PDF文件）
+    # 检查文件是否实际为PDF（无论扩展名如何）
+    is_pdf_file = False
+    if PYPDF2_AVAILABLE:
+        try:
+            with open(file_path, "rb") as f:
+                header = f.read(8)
+                is_pdf_file = header.startswith(b"%PDF")
+        except Exception:
+            is_pdf_file = file_path.lower().endswith(".pdf")
+
+    if is_pdf_file and PYPDF2_AVAILABLE:
+        try:
+            simple_converter = SimplePdfConverter()
+            conversion_result = simple_converter.convert_pdf_to_markdown(file_path)
+            if conversion_result["success"]:
+                conversion_msg = "\n   [INFO] PDF converted to Markdown (PyPDF2)"
+                conversion_msg += (
+                    f"\n   Markdown file: {conversion_result['output_file']}"
+                )
+                conversion_msg += (
+                    f"\n   Conversion time: {conversion_result['duration']:.2f} seconds"
+                )
+                conversion_msg += (
+                    f"\n   Pages extracted: {conversion_result['pages_extracted']}"
+                )
+
+            else:
+                conversion_msg = f"\n   [WARNING] PDF conversion failed: {conversion_result['error']}"
+        except Exception as conv_error:
+            conversion_msg = f"\n   [WARNING] PDF conversion error: {str(conv_error)}"
+
+    # 如果简单转换失败，尝试使用docling（支持图片提取）
+    # if not conversion_success and DOCLING_AVAILABLE:
+    #     try:
+    #         converter = DoclingConverter()
+    #         if converter.is_supported_format(file_path):
+    #             conversion_result = converter.convert_to_markdown(
+    #                 file_path, extract_images=extract_images
+    #             )
+    #             if conversion_result["success"]:
+    #                 conversion_msg = (
+    #                     "\n   [INFO] Document converted to Markdown (docling)"
+    #                 )
+    #                 conversion_msg += (
+    #                     f"\n   Markdown file: {conversion_result['output_file']}"
+    #                 )
+    #                 conversion_msg += f"\n   Conversion time: {conversion_result['duration']:.2f} seconds"
+    #                 if conversion_result.get("images_extracted", 0) > 0:
+    #                     conversion_msg += f"\n   Images extracted: {conversion_result['images_extracted']}"
+    #                     images_dir = os.path.join(
+    #                         os.path.dirname(conversion_result["output_file"]), "images"
+    #                     )
+    #                     conversion_msg += f"\n   Images saved to: {images_dir}"
+    #             else:
+    #                 conversion_msg = f"\n   [WARNING] Docling conversion failed: {conversion_result['error']}"
+    #     except Exception as conv_error:
+    #         conversion_msg = (
+    #             f"\n   [WARNING] Docling conversion error: {str(conv_error)}"
+    #         )
+
+    return conversion_msg if conversion_msg else None
+
+
+def format_file_operation_result(
+    operation: str,
+    source: str,
+    destination: str,
+    result: Dict[str, Any],
+    conversion_msg: Optional[str] = None,
+) -> str:
+    """
+    格式化文件操作结果的共用逻辑
+
+    Args:
+        operation: 操作类型 ("download" 或 "move")
+        source: 源文件/URL
+        destination: 目标路径
+        result: 操作结果字典
+        conversion_msg: 转换消息
+
+    Returns:
+        格式化的结果消息
+    """
+    if result["success"]:
+        size_mb = result["size"] / (1024 * 1024)
+        msg = f"[SUCCESS] Successfully {operation}d: {source}\n"
+
+        if operation == "download":
+            msg += f"   File: {destination}\n"
+            msg += f"   Size: {size_mb:.2f} MB\n"
+            msg += f"   Time: {result['duration']:.2f} seconds\n"
+            speed_mb = result.get("speed", 0) / (1024 * 1024)
+            msg += f"   Speed: {speed_mb:.2f} MB/s"
+        else:  # move
+            msg += f"   To: {destination}\n"
+            msg += f"   Size: {size_mb:.2f} MB\n"
+            msg += f"   Time: {result['duration']:.2f} seconds"
+
+        if conversion_msg:
+            msg += conversion_msg
+
+        return msg
+    else:
+        return f"[ERROR] Failed to {operation}: {source}\n   Error: {result.get('error', 'Unknown error')}"
+
+
+class LocalPathExtractor:
+    """本地路径提取器"""
+
+    @staticmethod
+    def is_local_path(path: str) -> bool:
+        """判断是否为本地路径"""
+        path = path.strip("\"'")
+
+        # 检查是否为URL
+        if re.match(r"^https?://", path, re.IGNORECASE) or re.match(
+            r"^ftp://", path, re.IGNORECASE
+        ):
+            return False
+
+        # 路径指示符
+        path_indicators = [os.path.sep, "/", "\\", "~", ".", ".."]
+        has_extension = bool(os.path.splitext(path)[1])
+
+        if any(indicator in path for indicator in path_indicators) or has_extension:
+            expanded_path = os.path.expanduser(path)
+            return os.path.exists(expanded_path) or any(
+                indicator in path for indicator in path_indicators
+            )
+
+        return False
+
+    @staticmethod
+    def extract_local_paths(text: str) -> List[str]:
+        """从文本中提取本地文件路径"""
+        patterns = [
+            r'"([^"]+)"',
+            r"'([^']+)'",
+            r"(?:^|\s)((?:[~./\\]|[A-Za-z]:)?(?:[^/\\\s]+[/\\])*[^/\\\s]+\.[A-Za-z0-9]+)(?:\s|$)",
+            r"(?:^|\s)((?:~|\.{1,2})?/[^\s]+)(?:\s|$)",
+            r"(?:^|\s)([A-Za-z]:[/\\][^\s]+)(?:\s|$)",
+            r"(?:^|\s)(\.{1,2}[/\\][^\s]+)(?:\s|$)",
+        ]
+
+        local_paths = []
+        potential_paths = []
+
+        for pattern in patterns:
+            matches = re.findall(pattern, text, re.MULTILINE)
+            potential_paths.extend(matches)
+
+        for path in potential_paths:
+            path = path.strip()
+            if path and LocalPathExtractor.is_local_path(path):
+                expanded_path = os.path.expanduser(path)
+                if expanded_path not in local_paths:
+                    local_paths.append(expanded_path)
+
+        return local_paths
+
+
+class URLExtractor:
+    """URL提取器"""
+
+    URL_PATTERNS = [
+        r"https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+(?:/(?:[-\w._~!$&\'()*+,;=:@]|%[\da-fA-F]{2})*)*(?:\?(?:[-\w._~!$&\'()*+,;=:@/?]|%[\da-fA-F]{2})*)?(?:#(?:[-\w._~!$&\'()*+,;=:@/?]|%[\da-fA-F]{2})*)?",
+        r"ftp://(?:[-\w.]|(?:%[\da-fA-F]{2}))+(?:/(?:[-\w._~!$&\'()*+,;=:@]|%[\da-fA-F]{2})*)*",
+        r"(?<!\S)(?:www\.)?[-\w]+(?:\.[-\w]+)+/(?:[-\w._~!$&\'()*+,;=:@/]|%[\da-fA-F]{2})+",
+    ]
+
+    @staticmethod
+    def convert_arxiv_url(url: str) -> str:
+        """将arXiv网页链接转换为PDF下载链接"""
+        # 匹配arXiv论文ID的正则表达式
+        arxiv_pattern = r"arxiv\.org/abs/(\d+\.\d+)(?:v\d+)?"
+        match = re.search(arxiv_pattern, url, re.IGNORECASE)
+        if match:
+            paper_id = match.group(1)
+            return f"https://arxiv.org/pdf/{paper_id}.pdf"
+        return url
+
+    @classmethod
+    def extract_urls(cls, text: str) -> List[str]:
+        """从文本中提取URL"""
+        urls = []
+
+        # 首先处理特殊情况：@开头的URL
+        at_url_pattern = r"@(https?://[^\s]+)"
+        at_matches = re.findall(at_url_pattern, text, re.IGNORECASE)
+        for match in at_matches:
+            # 处理arXiv链接
+            url = cls.convert_arxiv_url(match.rstrip("/"))
+            urls.append(url)
+
+        # 然后使用原有的正则模式
+        for pattern in cls.URL_PATTERNS:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            for match in matches:
+                # 处理可能缺少协议的URL
+                if not match.startswith(("http://", "https://", "ftp://")):
+                    # 检查是否是 www 开头
+                    if match.startswith("www."):
+                        match = "https://" + match
+                    else:
+                        # 其他情况也添加 https
+                        match = "https://" + match
+
+                # 处理arXiv链接
+                url = cls.convert_arxiv_url(match.rstrip("/"))
+                urls.append(url)
+
+        # 去重并保持顺序
+        seen = set()
+        unique_urls = []
+        for url in urls:
+            if url not in seen:
+                seen.add(url)
+                unique_urls.append(url)
+
+        return unique_urls
+
+    @staticmethod
+    def infer_filename_from_url(url: str) -> str:
+        """从URL推断文件名"""
+        parsed = urlparse(url)
+        path = unquote(parsed.path)
+
+        # 从路径中提取文件名
+        filename = os.path.basename(path)
+
+        # 特殊处理：arxiv PDF链接
+        if "arxiv.org" in parsed.netloc and "/pdf/" in path:
+            if filename:
+                # 检查是否已经有合适的文件扩展名
+                if not filename.lower().endswith((".pdf", ".doc", ".docx", ".txt")):
+                    filename = f"{filename}.pdf"
+            else:
+                path_parts = [p for p in path.split("/") if p]
+                if path_parts and path_parts[-1]:
+                    filename = f"{path_parts[-1]}.pdf"
+                else:
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    filename = f"arxiv_paper_{timestamp}.pdf"
+
+        # 如果没有文件名或没有扩展名，生成一个
+        elif not filename or "." not in filename:
+            # 尝试从URL生成有意义的文件名
+            domain = parsed.netloc.replace("www.", "").replace(".", "_")
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+            # 尝试根据路径推断文件类型
+            if not path or path == "/":
+                filename = f"{domain}_{timestamp}.html"
+            else:
+                # 使用路径的最后一部分
+                path_parts = [p for p in path.split("/") if p]
+                if path_parts:
+                    filename = f"{path_parts[-1]}_{timestamp}"
+                else:
+                    filename = f"{domain}_{timestamp}"
+
+                # 如果还是没有扩展名，根据路径推断
+                if "." not in filename:
+                    # 根据路径中的关键词推断文件类型
+                    if "/pdf/" in path.lower() or path.lower().endswith("pdf"):
+                        filename += ".pdf"
+                    elif any(
+                        ext in path.lower() for ext in ["/doc/", "/word/", ".docx"]
+                    ):
+                        filename += ".docx"
+                    elif any(
+                        ext in path.lower()
+                        for ext in ["/ppt/", "/powerpoint/", ".pptx"]
+                    ):
+                        filename += ".pptx"
+                    elif any(ext in path.lower() for ext in ["/csv/", ".csv"]):
+                        filename += ".csv"
+                    elif any(ext in path.lower() for ext in ["/zip/", ".zip"]):
+                        filename += ".zip"
+                    else:
+                        filename += ".html"
+
+        return filename
+
+
+class PathExtractor:
+    """路径提取器"""
+
+    @staticmethod
+    def extract_target_path(text: str) -> Optional[str]:
+        """从文本中提取目标路径"""
+        patterns = [
+            r'(?:save|download|store|put|place|write|copy|move)\s+(?:to|into|in|at)\s+["\']?([^\s"\']+)["\']?',
+            r'(?:to|into|in|at)\s+(?:folder|directory|dir|path|location)\s*["\']?([^\s"\']+)["\']?',
+            r'(?:destination|target|output)\s*(?:is|:)?\s*["\']?([^\s"\']+)["\']?',
+            r'(?:保存|下载|存储|放到|写入|复制|移动)(?:到|至|去)\s*["\']?([^\s"\']+)["\']?',
+            r'(?:到|在|至)\s*["\']?([^\s"\']+)["\']?\s*(?:文件夹|目录|路径|位置)',
+        ]
+
+        filter_words = {
+            "here",
+            "there",
+            "current",
+            "local",
+            "this",
+            "that",
+            "这里",
+            "那里",
+            "当前",
+            "本地",
+            "这个",
+            "那个",
+        }
+
+        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 filter_words:
+                    return path
+
+        return None
+
+
+class SimplePdfConverter:
+    """简单的PDF转换器，使用PyPDF2提取文本"""
+
+    def convert_pdf_to_markdown(
+        self, input_file: str, output_file: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        使用PyPDF2将PDF转换为Markdown格式
+
+        Args:
+            input_file: 输入PDF文件路径
+            output_file: 输出Markdown文件路径（可选）
+
+        Returns:
+            转换结果字典
+        """
+        if not PYPDF2_AVAILABLE:
+            return {"success": False, "error": "PyPDF2 package is not available"}
+
+        try:
+            # 检查输入文件是否存在
+            if not os.path.exists(input_file):
+                return {
+                    "success": False,
+                    "error": f"Input file not found: {input_file}",
+                }
+
+            # 如果没有指定输出文件，自动生成
+            if not output_file:
+                base_name = os.path.splitext(input_file)[0]
+                output_file = f"{base_name}.md"
+
+            # 确保输出目录存在
+            output_dir = os.path.dirname(output_file)
+            if output_dir:
+                os.makedirs(output_dir, exist_ok=True)
+
+            # 执行转换
+            start_time = datetime.now()
+
+            # 读取PDF文件
+            with open(input_file, "rb") as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                text_content = []
+
+                # 提取每页文本
+                for page_num, page in enumerate(pdf_reader.pages, 1):
+                    text = page.extract_text()
+                    if text.strip():
+                        text_content.append(f"## Page {page_num}\n\n{text.strip()}\n\n")
+
+            # 生成Markdown内容
+            markdown_content = f"# Extracted from {os.path.basename(input_file)}\n\n"
+            markdown_content += f"*Total pages: {len(pdf_reader.pages)}*\n\n"
+            markdown_content += "---\n\n"
+            markdown_content += "".join(text_content)
+
+            # 保存到文件
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.write(markdown_content)
+
+            # 计算转换时间
+            duration = (datetime.now() - start_time).total_seconds()
+
+            # 获取文件大小
+            input_size = os.path.getsize(input_file)
+            output_size = os.path.getsize(output_file)
+
+            return {
+                "success": True,
+                "input_file": input_file,
+                "output_file": output_file,
+                "input_size": input_size,
+                "output_size": output_size,
+                "duration": duration,
+                "markdown_content": markdown_content,
+                "pages_extracted": len(pdf_reader.pages),
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "input_file": input_file,
+                "error": f"Conversion failed: {str(e)}",
+            }
+
+
+class DoclingConverter:
+    """文档转换器，使用docling将文档转换为Markdown格式，支持图片提取"""
+
+    def __init__(self):
+        if not DOCLING_AVAILABLE:
+            raise ImportError(
+                "docling package is not available. Please install it first."
+            )
+
+        # 配置PDF处理选项
+        pdf_pipeline_options = PdfPipelineOptions()
+        pdf_pipeline_options.do_ocr = False  # 暂时禁用OCR以避免认证问题
+        pdf_pipeline_options.do_table_structure = False  # 暂时禁用表格结构识别
+
+        # 创建文档转换器（使用基础模式）
+        try:
+            self.converter = DocumentConverter(
+                format_options={
+                    InputFormat.PDF: PdfFormatOption(
+                        pipeline_options=pdf_pipeline_options
+                    )
+                }
+            )
+        except Exception:
+            # 如果失败，尝试更简单的配置
+            self.converter = DocumentConverter()
+
+    def is_supported_format(self, file_path: str) -> bool:
+        """检查文件格式是否支持转换"""
+        if not DOCLING_AVAILABLE:
+            return False
+
+        supported_extensions = {".pdf", ".docx", ".pptx", ".html", ".md", ".txt"}
+        file_extension = os.path.splitext(file_path)[1].lower()
+        return file_extension in supported_extensions
+
+    def is_url(self, path: str) -> bool:
+        """检查路径是否为URL"""
+        try:
+            result = urlparse(path)
+            return result.scheme in ("http", "https")
+        except Exception:
+            return False
+
+    def extract_images(self, doc, output_dir: str) -> Dict[str, str]:
+        """
+        提取文档中的图片并保存到本地
+
+        Args:
+            doc: docling文档对象
+            output_dir: 输出目录
+
+        Returns:
+            图片ID到本地文件路径的映射
+        """
+        images_dir = os.path.join(output_dir, "images")
+        os.makedirs(images_dir, exist_ok=True)
+        image_map = {}  # docling图片id -> 本地文件名
+
+        try:
+            # 获取文档中的图片
+            images = getattr(doc, "images", [])
+
+            for idx, img in enumerate(images):
+                try:
+                    # 获取图片格式，默认为png
+                    ext = getattr(img, "format", None) or "png"
+                    if ext.lower() not in ["png", "jpg", "jpeg", "gif", "bmp", "webp"]:
+                        ext = "png"
+
+                    # 生成文件名
+                    filename = f"image_{idx+1}.{ext}"
+                    filepath = os.path.join(images_dir, filename)
+
+                    # 保存图片数据
+                    img_data = getattr(img, "data", None)
+                    if img_data:
+                        with open(filepath, "wb") as f:
+                            f.write(img_data)
+
+                        # 计算相对路径
+                        rel_path = os.path.relpath(filepath, output_dir)
+                        img_id = getattr(img, "id", str(idx + 1))
+                        image_map[img_id] = rel_path
+
+                except Exception as img_error:
+                    print(f"Warning: Failed to extract image {idx+1}: {img_error}")
+                    continue
+
+        except Exception as e:
+            print(f"Warning: Failed to extract images: {e}")
+
+        return image_map
+
+    def process_markdown_with_images(
+        self, markdown_content: str, image_map: Dict[str, str]
+    ) -> str:
+        """
+        处理Markdown内容，替换图片占位符为实际的图片路径
+
+        Args:
+            markdown_content: 原始Markdown内容
+            image_map: 图片ID到本地路径的映射
+
+        Returns:
+            处理后的Markdown内容
+        """
+
+        def replace_img(match):
+            img_id = match.group(1)
+            if img_id in image_map:
+                return f"![Image]({image_map[img_id]})"
+            else:
+                return match.group(0)
+
+        # 替换docling的图片占位符
+        processed_content = re.sub(
+            r"!\[Image\]\(docling://image/([^)]+)\)", replace_img, markdown_content
+        )
+
+        return processed_content
+
+    def convert_to_markdown(
+        self,
+        input_file: str,
+        output_file: Optional[str] = None,
+        extract_images: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        将文档转换为Markdown格式，支持图片提取
+
+        Args:
+            input_file: 输入文件路径或URL
+            output_file: 输出Markdown文件路径（可选）
+            extract_images: 是否提取图片（默认True）
+
+        Returns:
+            转换结果字典
+        """
+        if not DOCLING_AVAILABLE:
+            return {"success": False, "error": "docling package is not available"}
+
+        try:
+            # 检查输入文件（如果不是URL）
+            if not self.is_url(input_file):
+                if not os.path.exists(input_file):
+                    return {
+                        "success": False,
+                        "error": f"Input file not found: {input_file}",
+                    }
+
+                # 检查文件格式是否支持
+                if not self.is_supported_format(input_file):
+                    return {
+                        "success": False,
+                        "error": f"Unsupported file format: {os.path.splitext(input_file)[1]}",
+                    }
+            else:
+                # 对于URL，检查是否为支持的格式
+                if not input_file.lower().endswith(
+                    (".pdf", ".docx", ".pptx", ".html", ".md", ".txt")
+                ):
+                    return {
+                        "success": False,
+                        "error": f"Unsupported URL format: {input_file}",
+                    }
+
+            # 如果没有指定输出文件，自动生成
+            if not output_file:
+                if self.is_url(input_file):
+                    # 从URL生成文件名
+                    filename = URLExtractor.infer_filename_from_url(input_file)
+                    base_name = os.path.splitext(filename)[0]
+                else:
+                    base_name = os.path.splitext(input_file)[0]
+                output_file = f"{base_name}.md"
+
+            # 确保输出目录存在
+            output_dir = os.path.dirname(output_file) or "."
+            os.makedirs(output_dir, exist_ok=True)
+
+            # 执行转换
+            start_time = datetime.now()
+            result = self.converter.convert(input_file)
+            doc = result.document
+
+            # 提取图片（如果启用）
+            image_map = {}
+            images_extracted = 0
+            if extract_images:
+                image_map = self.extract_images(doc, output_dir)
+                images_extracted = len(image_map)
+
+            # 获取Markdown内容
+            markdown_content = doc.export_to_markdown()
+
+            # 处理图片占位符
+            if extract_images and image_map:
+                markdown_content = self.process_markdown_with_images(
+                    markdown_content, image_map
+                )
+
+            # 保存到文件
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.write(markdown_content)
+
+            # 计算转换时间
+            duration = (datetime.now() - start_time).total_seconds()
+
+            # 获取文件大小
+            if self.is_url(input_file):
+                input_size = 0  # URL无法直接获取大小
+            else:
+                input_size = os.path.getsize(input_file)
+            output_size = os.path.getsize(output_file)
+
+            return {
+                "success": True,
+                "input_file": input_file,
+                "output_file": output_file,
+                "input_size": input_size,
+                "output_size": output_size,
+                "duration": duration,
+                "markdown_content": markdown_content,
+                "images_extracted": images_extracted,
+                "image_map": image_map,
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "input_file": input_file,
+                "error": f"Conversion failed: {str(e)}",
+            }
+
+
+async def check_url_accessible(url: str) -> Dict[str, Any]:
+    """检查URL是否可访问"""
+    try:
+        timeout = aiohttp.ClientTimeout(total=10)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.head(url, allow_redirects=True) as response:
+                return {
+                    "accessible": response.status < 400,
+                    "status": response.status,
+                    "content_type": response.headers.get("Content-Type", ""),
+                    "content_length": response.headers.get("Content-Length", 0),
+                }
+    except Exception:
+        return {
+            "accessible": False,
+            "status": 0,
+            "content_type": "",
+            "content_length": 0,
+        }
+
+
+async def download_file(url: str, destination: str) -> Dict[str, Any]:
+    """下载单个文件"""
+    start_time = datetime.now()
+    chunk_size = 8192
+
+    try:
+        timeout = aiohttp.ClientTimeout(total=300)  # 5分钟超时
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(url) as response:
+                # 检查响应状态
+                response.raise_for_status()
+
+                # 获取文件信息
+                content_type = response.headers.get(
+                    "Content-Type", "application/octet-stream"
+                )
+
+                # 确保目标目录存在
+                parent_dir = os.path.dirname(destination)
+                if parent_dir:
+                    os.makedirs(parent_dir, exist_ok=True)
+
+                # 下载文件
+                downloaded = 0
+                async with aiofiles.open(destination, "wb") as file:
+                    async for chunk in response.content.iter_chunked(chunk_size):
+                        await file.write(chunk)
+                        downloaded += len(chunk)
+
+                # 计算下载时间
+                duration = (datetime.now() - start_time).total_seconds()
+
+                return {
+                    "success": True,
+                    "url": url,
+                    "destination": destination,
+                    "size": downloaded,
+                    "content_type": content_type,
+                    "duration": duration,
+                    "speed": downloaded / duration if duration > 0 else 0,
+                }
+
+    except aiohttp.ClientError as e:
+        return {
+            "success": False,
+            "url": url,
+            "destination": destination,
+            "error": f"Network error: {str(e)}",
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "url": url,
+            "destination": destination,
+            "error": f"Download error: {str(e)}",
+        }
+
+
+async def move_local_file(source_path: str, destination: str) -> Dict[str, Any]:
+    """移动本地文件到目标位置"""
+    start_time = datetime.now()
+
+    try:
+        # 检查源文件是否存在
+        if not os.path.exists(source_path):
+            return {
+                "success": False,
+                "source": source_path,
+                "destination": destination,
+                "error": f"Source file not found: {source_path}",
+            }
+
+        # 获取源文件信息
+        source_size = os.path.getsize(source_path)
+
+        # 确保目标目录存在
+        parent_dir = os.path.dirname(destination)
+        if parent_dir:
+            os.makedirs(parent_dir, exist_ok=True)
+
+        # 执行移动操作
+        shutil.move(source_path, destination)
+
+        # 计算操作时间
+        duration = (datetime.now() - start_time).total_seconds()
+
+        return {
+            "success": True,
+            "source": source_path,
+            "destination": destination,
+            "size": source_size,
+            "duration": duration,
+            "operation": "move",
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "source": source_path,
+            "destination": destination,
+            "error": f"Move error: {str(e)}",
+        }
+
+
+@mcp.tool()
+async def download_files(instruction: str) -> str:
+    """
+    Download files from URLs or move local files mentioned in natural language instructions.
+
+    Args:
+        instruction: Natural language instruction containing URLs/local paths and optional destination paths
+
+    Returns:
+        Status message about the download/move operations
+
+    Examples:
+        - "Download https://example.com/file.pdf to documents folder"
+        - "Move /home/user/file.pdf to documents folder"
+        - "Please get https://raw.githubusercontent.com/user/repo/main/data.csv and save it to ~/downloads"
+        - "移动 ~/Desktop/report.docx 到 /tmp/documents/"
+        - "Download www.example.com/report.xlsx"
+    """
+    urls = URLExtractor.extract_urls(instruction)
+    local_paths = LocalPathExtractor.extract_local_paths(instruction)
+
+    if not urls and not local_paths:
+        return format_error_message(
+            "Failed to parse instruction",
+            "No downloadable URLs or movable local files found",
+        )
+
+    target_path = PathExtractor.extract_target_path(instruction)
+
+    # 处理文件
+    results = []
+
+    # 处理URL下载
+    for url in urls:
+        try:
+            # 推断文件名
+            filename = URLExtractor.infer_filename_from_url(url)
+
+            # 构建完整的目标路径
+            if target_path:
+                # 处理路径
+                if target_path.startswith("~"):
+                    target_path = os.path.expanduser(target_path)
+
+                # 确保使用相对路径（如果不是绝对路径）
+                if not os.path.isabs(target_path):
+                    target_path = os.path.normpath(target_path)
+
+                # 判断是文件路径还是目录路径
+                if os.path.splitext(target_path)[1]:  # 有扩展名，是文件
+                    destination = target_path
+                else:  # 是目录
+                    destination = os.path.join(target_path, filename)
+            else:
+                # 默认下载到当前目录
+                destination = filename
+
+            # 检查文件是否已存在
+            if os.path.exists(destination):
+                results.append(
+                    f"[WARNING] Skipped {url}: File already exists at {destination}"
+                )
+                continue
+
+            # 先检查URL是否可访问
+            check_result = await check_url_accessible(url)
+            if not check_result["accessible"]:
+                results.append(
+                    f"[ERROR] Failed to access {url}: HTTP {check_result['status'] or 'Connection failed'}"
+                )
+                continue
+
+            # 执行下载
+            result = await download_file(url, destination)
+
+            # 执行转换（如果成功下载）
+            conversion_msg = None
+            if result["success"]:
+                conversion_msg = await perform_document_conversion(
+                    destination, extract_images=True
+                )
+
+            # 格式化结果
+            msg = format_file_operation_result(
+                "download", url, destination, result, conversion_msg
+            )
+
+        except Exception as e:
+            msg = f"[ERROR] Failed to download: {url}\n"
+            msg += f"   Error: {str(e)}"
+
+        results.append(msg)
+
+    # 处理本地文件移动
+    for local_path in local_paths:
+        try:
+            # 获取文件名
+            filename = os.path.basename(local_path)
+
+            # 构建完整的目标路径
+            if target_path:
+                # 处理路径
+                if target_path.startswith("~"):
+                    target_path = os.path.expanduser(target_path)
+
+                # 确保使用相对路径（如果不是绝对路径）
+                if not os.path.isabs(target_path):
+                    target_path = os.path.normpath(target_path)
+
+                # 判断是文件路径还是目录路径
+                if os.path.splitext(target_path)[1]:  # 有扩展名，是文件
+                    destination = target_path
+                else:  # 是目录
+                    destination = os.path.join(target_path, filename)
+            else:
+                # 默认移动到当前目录
+                destination = filename
+
+            # 检查目标文件是否已存在
+            if os.path.exists(destination):
+                results.append(
+                    f"[WARNING] Skipped {local_path}: File already exists at {destination}"
+                )
+                continue
+
+            # 执行移动
+            result = await move_local_file(local_path, destination)
+
+            # 执行转换（如果成功移动）
+            conversion_msg = None
+            if result["success"]:
+                conversion_msg = await perform_document_conversion(
+                    destination, extract_images=True
+                )
+
+            # 格式化结果
+            msg = format_file_operation_result(
+                "move", local_path, destination, result, conversion_msg
+            )
+
+        except Exception as e:
+            msg = f"[ERROR] Failed to move: {local_path}\n"
+            msg += f"   Error: {str(e)}"
+
+        results.append(msg)
+
+    return "\n\n".join(results)
+
+
+@mcp.tool()
+async def parse_download_urls(text: str) -> str:
+    """
+    Extract URLs, local paths and target paths from text without downloading or moving.
+
+    Args:
+        text: Text containing URLs, local paths and optional destination paths
+
+    Returns:
+        Parsed URLs, local paths and target path information
+    """
+    urls = URLExtractor.extract_urls(text)
+    local_paths = LocalPathExtractor.extract_local_paths(text)
+    target_path = PathExtractor.extract_target_path(text)
+
+    content = "📋 Parsed file operation information:\n\n"
+
+    if urls:
+        content += f"🔗 URLs found ({len(urls)}):\n"
+        for i, url in enumerate(urls, 1):
+            filename = URLExtractor.infer_filename_from_url(url)
+            content += f"  {i}. {url}\n     📄 Filename: {filename}\n"
+    else:
+        content += "🔗 No URLs found\n"
+
+    if local_paths:
+        content += f"\n📁 Local files found ({len(local_paths)}):\n"
+        for i, path in enumerate(local_paths, 1):
+            exists = os.path.exists(path)
+            content += f"  {i}. {path}\n"
+            content += f"     ✅ Exists: {'Yes' if exists else 'No'}\n"
+            if exists:
+                size_mb = os.path.getsize(path) / (1024 * 1024)
+                content += f"     📊 Size: {size_mb:.2f} MB\n"
+    else:
+        content += "\n📁 No local files found\n"
+
+    if target_path:
+        content += f"\n🎯 Target path: {target_path}"
+        if target_path.startswith("~"):
+            content += f"\n   (Expanded: {os.path.expanduser(target_path)})"
+    else:
+        content += "\n🎯 Target path: Not specified (will use current directory)"
+
+    return content
+
+
+@mcp.tool()
+async def download_file_to(
+    url: str, destination: Optional[str] = None, filename: Optional[str] = None
+) -> str:
+    """
+    Download a specific file with detailed options.
+
+    Args:
+        url: URL to download from
+        destination: Target directory or full file path (optional)
+        filename: Specific filename to use (optional, ignored if destination is a full file path)
+
+    Returns:
+        Status message about the download operation
+    """
+    # 确定文件名
+    if not filename:
+        filename = URLExtractor.infer_filename_from_url(url)
+
+    # 确定完整路径
+    if destination:
+        # 展开用户目录
+        if destination.startswith("~"):
+            destination = os.path.expanduser(destination)
+
+        # 检查是否是完整文件路径
+        if os.path.splitext(destination)[1]:  # 有扩展名
+            target_path = destination
+        else:  # 是目录
+            target_path = os.path.join(destination, filename)
+    else:
+        target_path = filename
+
+    # 确保使用相对路径（如果不是绝对路径）
+    if not os.path.isabs(target_path):
+        target_path = os.path.normpath(target_path)
+
+    # 检查文件是否已存在
+    if os.path.exists(target_path):
+        return format_error_message(
+            "Download aborted", f"File already exists at {target_path}"
+        )
+
+    # 先检查URL
+    check_result = await check_url_accessible(url)
+    if not check_result["accessible"]:
+        return format_error_message(
+            "Cannot access URL",
+            f"{url} (HTTP {check_result['status'] or 'Connection failed'})",
+        )
+
+    # 显示下载信息
+    size_mb = (
+        int(check_result["content_length"]) / (1024 * 1024)
+        if check_result["content_length"]
+        else 0
+    )
+    msg = "[INFO] Downloading file:\n"
+    msg += f"   URL: {url}\n"
+    msg += f"   Target: {target_path}\n"
+    if size_mb > 0:
+        msg += f"   Expected size: {size_mb:.2f} MB\n"
+    msg += "\n"
+
+    # 执行下载
+    result = await download_file(url, target_path)
+
+    # 执行转换（如果成功下载）
+    conversion_msg = None
+    if result["success"]:
+        conversion_msg = await perform_document_conversion(
+            target_path, extract_images=True
+        )
+
+        # 添加下载信息前缀
+        actual_size_mb = result["size"] / (1024 * 1024)
+        speed_mb = result["speed"] / (1024 * 1024)
+        info_msg = "[SUCCESS] Download completed!\n"
+        info_msg += f"   Saved to: {target_path}\n"
+        info_msg += f"   Size: {actual_size_mb:.2f} MB\n"
+        info_msg += f"   Duration: {result['duration']:.2f} seconds\n"
+        info_msg += f"   Speed: {speed_mb:.2f} MB/s\n"
+        info_msg += f"   Type: {result['content_type']}"
+
+        if conversion_msg:
+            info_msg += conversion_msg
+
+        return msg + info_msg
+    else:
+        return msg + f"[ERROR] Download failed!\n   Error: {result['error']}"
+
+
+@mcp.tool()
+async def move_file_to(
+    source: str, destination: Optional[str] = None, filename: Optional[str] = None
+) -> str:
+    """
+    Move a local file to a new location with detailed options.
+
+    Args:
+        source: Source file path to move
+        destination: Target directory or full file path (optional)
+        filename: Specific filename to use (optional, ignored if destination is a full file path)
+
+    Returns:
+        Status message about the move operation
+    """
+    # 展开源路径
+    if source.startswith("~"):
+        source = os.path.expanduser(source)
+
+    # 检查源文件是否存在
+    if not os.path.exists(source):
+        return format_error_message("Move aborted", f"Source file not found: {source}")
+
+    # 确定文件名
+    if not filename:
+        filename = os.path.basename(source)
+
+    # 确定完整路径
+    if destination:
+        # 展开用户目录
+        if destination.startswith("~"):
+            destination = os.path.expanduser(destination)
+
+        # 检查是否是完整文件路径
+        if os.path.splitext(destination)[1]:  # 有扩展名
+            target_path = destination
+        else:  # 是目录
+            target_path = os.path.join(destination, filename)
+    else:
+        target_path = filename
+
+    # 确保使用相对路径（如果不是绝对路径）
+    if not os.path.isabs(target_path):
+        target_path = os.path.normpath(target_path)
+
+    # 检查目标文件是否已存在
+    if os.path.exists(target_path):
+        return f"[ERROR] Target file already exists: {target_path}"
+
+    # 显示移动信息
+    source_size_mb = os.path.getsize(source) / (1024 * 1024)
+    msg = "[INFO] Moving file:\n"
+    msg += f"   Source: {source}\n"
+    msg += f"   Target: {target_path}\n"
+    msg += f"   Size: {source_size_mb:.2f} MB\n"
+    msg += "\n"
+
+    # 执行移动
+    result = await move_local_file(source, target_path)
+
+    # 执行转换（如果成功移动）
+    conversion_msg = None
+    if result["success"]:
+        conversion_msg = await perform_document_conversion(
+            target_path, extract_images=True
+        )
+
+        # 添加移动信息前缀
+        info_msg = "[SUCCESS] File moved successfully!\n"
+        info_msg += f"   From: {source}\n"
+        info_msg += f"   To: {target_path}\n"
+        info_msg += f"   Duration: {result['duration']:.2f} seconds"
+
+        if conversion_msg:
+            info_msg += conversion_msg
+
+        return msg + info_msg
+    else:
+        return msg + f"[ERROR] Move failed!\n   Error: {result['error']}"
+
+
+# @mcp.tool()
+# async def convert_document_to_markdown(
+#     file_path: str, output_path: Optional[str] = None, extract_images: bool = True
+# ) -> str:
+#     """
+#     Convert a document to Markdown format with image extraction support.
+
+#     Supports both local files and URLs. Uses docling for advanced conversion with image extraction,
+#     or falls back to PyPDF2 for simple PDF text extraction.
+
+#     Args:
+#         file_path: Path to the input document file or URL (supports PDF, DOCX, PPTX, HTML, TXT, MD)
+#         output_path: Path for the output Markdown file (optional, auto-generated if not provided)
+#         extract_images: Whether to extract images from the document (default: True)
+
+#     Returns:
+#         Status message about the conversion operation with preview of converted content
+
+#     Examples:
+#         - "convert_document_to_markdown('paper.pdf')"
+#         - "convert_document_to_markdown('https://example.com/doc.pdf', 'output.md')"
+#         - "convert_document_to_markdown('presentation.pptx', extract_images=False)"
+#     """
+#     # 检查是否为URL
+#     is_url_input = False
+#     try:
+#         parsed = urlparse(file_path)
+#         is_url_input = parsed.scheme in ("http", "https")
+#     except Exception:
+#         is_url_input = False
+
+#     # 检查文件是否存在（如果不是URL）
+#     if not is_url_input and not os.path.exists(file_path):
+#         return f"[ERROR] Input file not found: {file_path}"
+
+#     # 检查是否是PDF文件，优先使用简单转换器（仅对本地文件）
+#     if (
+#         not is_url_input
+#         and file_path.lower().endswith(".pdf")
+#         and PYPDF2_AVAILABLE
+#         and not extract_images
+#     ):
+#         try:
+#             simple_converter = SimplePdfConverter()
+#             result = simple_converter.convert_pdf_to_markdown(file_path, output_path)
+#         except Exception as e:
+#             return f"[ERROR] PDF conversion error: {str(e)}"
+#     elif DOCLING_AVAILABLE:
+#         try:
+#             converter = DoclingConverter()
+
+#             # 检查文件格式是否支持
+#             if not is_url_input and not converter.is_supported_format(file_path):
+#                 supported_formats = [".pdf", ".docx", ".pptx", ".html", ".md", ".txt"]
+#                 return f"[ERROR] Unsupported file format. Supported formats: {', '.join(supported_formats)}"
+#             elif is_url_input and not file_path.lower().endswith(
+#                 (".pdf", ".docx", ".pptx", ".html", ".md", ".txt")
+#             ):
+#                 return f"[ERROR] Unsupported URL format: {file_path}"
+
+#             # 执行转换（支持图片提取）
+#             result = converter.convert_to_markdown(
+#                 file_path, output_path, extract_images
+#             )
+#         except Exception as e:
+#             return f"[ERROR] Docling conversion error: {str(e)}"
+#     else:
+#         return (
+#             "[ERROR] No conversion tools available. Please install docling or PyPDF2."
+#         )
+
+#     if result["success"]:
+#         msg = "[SUCCESS] Document converted successfully!\n"
+#         msg += f"   Input: {result['input_file']}\n"
+#         msg += f"   Output file: {result['output_file']}\n"
+#         msg += f"   Conversion time: {result['duration']:.2f} seconds\n"
+
+#         if result["input_size"] > 0:
+#             msg += f"   Original size: {result['input_size'] / 1024:.1f} KB\n"
+#         msg += f"   Markdown size: {result['output_size'] / 1024:.1f} KB\n"
+
+#         # 显示图片提取信息
+#         if extract_images and "images_extracted" in result:
+#             images_count = result["images_extracted"]
+#             if images_count > 0:
+#                 msg += f"   Images extracted: {images_count}\n"
+#                 msg += f"   Images saved to: {os.path.join(os.path.dirname(result['output_file']), 'images')}\n"
+#             else:
+#                 msg += "   No images found in document\n"
+
+#         # 显示Markdown内容的前几行作为预览
+#         content_lines = result["markdown_content"].split("\n")
+#         preview_lines = content_lines[:5]
+#         if len(content_lines) > 5:
+#             preview_lines.append("...")
+
+#         msg += "\n[PREVIEW] First few lines of converted Markdown:\n"
+#         for line in preview_lines:
+#             msg += f"   {line}\n"
+#     else:
+#         msg = "[ERROR] Conversion failed!\n"
+#         msg += f"   Error: {result['error']}"
+
+#     return msg
+
+
+if __name__ == "__main__":
+    print("📄 Smart PDF Downloader MCP Tool")
+    print("📝 Starting server with FastMCP...")
+
+    if DOCLING_AVAILABLE:
+        print("✅ Document conversion to Markdown is ENABLED (docling available)")
+    else:
+        print("❌ Document conversion to Markdown is DISABLED (docling not available)")
+        print("   Install docling to enable: pip install docling")
+
+    print("\nAvailable tools:")
+    print(
+        "  • download_files - Download files or move local files from natural language"
+    )
+    print("  • parse_download_urls - Extract URLs, local paths and destination paths")
+    print("  • download_file_to - Download a specific file with options")
+    print("  • move_file_to - Move a specific local file with options")
+    print("  • convert_document_to_markdown - Convert documents to Markdown format")
+
+    if DOCLING_AVAILABLE:
+        print("\nSupported formats: PDF, DOCX, PPTX, HTML, TXT, MD")
+        print("Features: Image extraction, Layout preservation, Automatic conversion")
+
+    print("")
+
+    # 运行服务器
+    mcp.run()

projects/ui/DeepCode/tools/pdf_utils.py

@@ -0,0 +1,52 @@
+"""
+PDF utility functions for the DeepCode agent system.
+"""
+
+from pathlib import Path
+import PyPDF2
+
+
+def read_pdf_metadata(file_path: Path) -> dict:
+    """Read PDF metadata with proper encoding handling."""
+    try:
+        print(f"\nAttempting to read PDF metadata from: {file_path}")
+        with open(file_path, "rb") as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            info = pdf_reader.metadata
+            first_page = pdf_reader.pages[0]
+            text = first_page.extract_text()
+            lines = text.split("\n")[:10]
+
+            title = None
+            authors = []
+
+            if info:
+                title = info.get("/Title", "").strip().replace("\x00", "")
+                author = info.get("/Author", "").strip().replace("\x00", "")
+                if author:
+                    authors = [author]
+
+            if not title and lines:
+                title = lines[0].strip()
+
+            if not authors and len(lines) > 1:
+                for line in lines[1:3]:
+                    if "author" in line.lower() or "by" in line.lower():
+                        authors = [line.strip()]
+                        break
+
+            return {
+                "title": title if title else "Unknown Title",
+                "authors": authors if authors else ["Unknown Author"],
+                "year": info.get("/CreationDate", "")[:4] if info else "Unknown Year",
+                "first_lines": lines,
+            }
+
+    except Exception as e:
+        print(f"\nError reading PDF: {str(e)}")
+        return {
+            "title": "Error reading PDF",
+            "authors": ["Unknown"],
+            "year": "Unknown",
+            "first_lines": [],
+        }

projects/ui/DeepCode/ui/__init__.py

@@ -0,0 +1,43 @@
+"""
+UI Module
+
+Streamlit application user interface components module
+
+Contains the following submodules:
+- styles: CSS styles
+- components: UI components
+- layout: Page layout
+- handlers: Event handlers
+- streamlit_app: Main application
+- app: Application entry
+"""
+
+__version__ = "1.0.0"
+__author__ = "DeepCode Team"
+
+# Import main components
+from .layout import main_layout
+from .components import display_header, display_features, display_status
+from .handlers import initialize_session_state
+from .styles import get_main_styles
+
+# Import application main function
+try:
+    from .streamlit_app import main as streamlit_main
+except ImportError:
+    # Fallback to absolute import if relative import fails
+    import sys
+    import os
+
+    sys.path.insert(0, os.path.dirname(__file__))
+    from streamlit_app import main as streamlit_main
+
+__all__ = [
+    "main_layout",
+    "display_header",
+    "display_features",
+    "display_status",
+    "initialize_session_state",
+    "get_main_styles",
+    "streamlit_main",
+]

projects/ui/DeepCode/ui/app.py

@@ -0,0 +1,13 @@
+"""
+DeepCode UI Application Entry Point
+
+This file serves as the unified entry point for the UI module
+"""
+
+from .streamlit_app import main
+
+# Directly export main function for external calls
+__all__ = ["main"]
+
+if __name__ == "__main__":
+    main()

projects/ui/DeepCode/ui/components.py

@@ -0,0 +1,1450 @@
+"""
+Streamlit UI Components Module
+
+Contains all reusable UI components
+"""
+
+import streamlit as st
+import sys
+from typing import Dict, Any, Optional
+from datetime import datetime
+import json
+
+
+def display_header():
+    """Display application header"""
+    st.markdown(
+        """
+    <div class="main-header">
+        <h1>🧬 DeepCode</h1>
+        <h3>OPEN-SOURCE CODE AGENT</h3>
+        <p>⚡ DATA INTELLIGENCE LAB @ HKU • REVOLUTIONIZING RESEARCH REPRODUCIBILITY ⚡</p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+
+def display_features():
+    """Display DeepCode AI Agent capabilities"""
+    # AI Agent core capabilities display area - updated to match README content
+    st.markdown(
+        """
+    <div class="ai-capabilities-section">
+        <div class="neural-network">
+            <div class="neuron pulse-1"></div>
+            <div class="neuron pulse-2"></div>
+            <div class="neuron pulse-3"></div>
+        </div>
+        <h2 class="capabilities-title">🧠 Open Agentic Coding Platform</h2>
+        <p class="capabilities-subtitle">Advancing Code Generation with Multi-Agent Systems</p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Core functionality modules - Vertical Layout
+    st.markdown(
+        """
+    <div class="feature-card-vertical primary">
+        <div class="card-glow-vertical"></div>
+        <div class="feature-header">
+            <div class="feature-logo-container">
+                <div class="ai-brain-logo">
+                    <div class="brain-node node-1"></div>
+                    <div class="brain-node node-2"></div>
+                    <div class="brain-node node-3"></div>
+                    <div class="brain-connection conn-1"></div>
+                    <div class="brain-connection conn-2"></div>
+                </div>
+                <div class="feature-icon-large">🚀</div>
+            </div>
+            <div class="feature-header-content">
+                <h3 class="feature-title-large">Paper2Code: Research-to-Production Pipeline</h3>
+                <p class="feature-subtitle">Automated Implementation of Complex Algorithms</p>
+            </div>
+            <div class="feature-stats">
+                <div class="stat-item">
+                    <span class="stat-number typing-number">Multi-Modal</span>
+                    <span class="stat-label">Analysis</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-number typing-number">Production</span>
+                    <span class="stat-label">Ready</span>
+                </div>
+            </div>
+        </div>
+        <div class="feature-content">
+            <div class="content-left">
+                <p class="feature-description-large">Multi-modal document analysis engine that extracts algorithmic logic and mathematical models from academic papers, generating optimized implementations with proper data structures while preserving computational complexity characteristics.</p>
+                <div class="feature-flow">
+                    <div class="flow-step active">
+                        <div class="flow-icon">📄</div>
+                        <span>Document Parsing</span>
+                    </div>
+                    <div class="flow-arrow">→</div>
+                    <div class="flow-step active">
+                        <div class="flow-icon">🧠</div>
+                        <span>Algorithm Extraction</span>
+                    </div>
+                    <div class="flow-arrow">→</div>
+                    <div class="flow-step active">
+                        <div class="flow-icon">⚡</div>
+                        <span>Code Synthesis</span>
+                    </div>
+                    <div class="flow-arrow">→</div>
+                    <div class="flow-step active">
+                        <div class="flow-icon">✅</div>
+                        <span>Quality Assurance</span>
+                    </div>
+                </div>
+            </div>
+            <div class="content-right">
+                <div class="code-simulation">
+                    <div class="code-header">
+                        <span class="code-lang">Python</span>
+                        <div class="code-status generating">Generating...</div>
+                    </div>
+                    <div class="code-lines">
+                        <div class="code-line typing">import torch</div>
+                        <div class="code-line typing delay-1">import torch.nn as nn</div>
+                        <div class="code-line typing delay-2">class ResearchAlgorithm(nn.Module):</div>
+                        <div class="code-line typing delay-3">    def __init__(self, config):</div>
+                        <div class="code-line typing delay-4">        super().__init__()</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+    <div class="feature-card-vertical secondary">
+        <div class="card-glow-vertical"></div>
+        <div class="feature-header">
+            <div class="feature-logo-container">
+                <div class="multi-agent-logo">
+                    <div class="agent-node agent-1">🎨</div>
+                    <div class="agent-node agent-2">💻</div>
+                    <div class="agent-node agent-3">⚡</div>
+                    <div class="agent-connection conn-12"></div>
+                    <div class="agent-connection conn-23"></div>
+                    <div class="agent-connection conn-13"></div>
+                </div>
+                <div class="feature-icon-large">🎨</div>
+            </div>
+            <div class="feature-header-content">
+                <h3 class="feature-title-large">Text2Web: Automated Prototyping Engine</h3>
+                <p class="feature-subtitle">Natural Language to Front-End Code Synthesis</p>
+            </div>
+            <div class="feature-stats">
+                <div class="stat-item">
+                    <span class="stat-number typing-number">Intelligent</span>
+                    <span class="stat-label">Scaffolding</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-number typing-number">Scalable</span>
+                    <span class="stat-label">Architecture</span>
+                </div>
+            </div>
+        </div>
+        <div class="feature-content">
+            <div class="content-left">
+                <p class="feature-description-large">Context-aware code generation using fine-tuned language models. Intelligent scaffolding system generating complete application structures including frontend components, maintaining architectural consistency across modules.</p>
+                <div class="agent-grid">
+                    <div class="agent-card active">
+                        <div class="agent-avatar">📝</div>
+                        <h4>Intent Understanding</h4>
+                        <p>Semantic analysis of requirements</p>
+                    </div>
+                    <div class="agent-card active">
+                        <div class="agent-avatar">🎨</div>
+                        <h4>UI Architecture</h4>
+                        <p>Component design & structure</p>
+                    </div>
+                    <div class="agent-card active">
+                        <div class="agent-avatar">💻</div>
+                        <h4>Code Generation</h4>
+                        <p>Functional interface creation</p>
+                    </div>
+                    <div class="agent-card active">
+                        <div class="agent-avatar">✨</div>
+                        <h4>Quality Assurance</h4>
+                        <p>Automated testing & validation</p>
+                    </div>
+                </div>
+            </div>
+            <div class="content-right">
+                <div class="collaboration-viz">
+                    <div class="collaboration-center">
+                        <div class="center-node">🎯</div>
+                        <span>Web Application</span>
+                    </div>
+                    <div class="collaboration-agents">
+                        <div class="collab-agent agent-pos-1">
+                            <div class="pulse-ring"></div>
+                            📝
+                        </div>
+                        <div class="collab-agent agent-pos-2">
+                            <div class="pulse-ring"></div>
+                            🏗️
+                        </div>
+                        <div class="collab-agent agent-pos-3">
+                            <div class="pulse-ring"></div>
+                            ⚙️
+                        </div>
+                        <div class="collab-agent agent-pos-4">
+                            <div class="pulse-ring"></div>
+                            🧪
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+    <div class="feature-card-vertical accent">
+        <div class="card-glow-vertical"></div>
+        <div class="feature-header">
+            <div class="feature-logo-container">
+                <div class="future-logo">
+                    <div class="orbit orbit-1">
+                        <div class="orbit-node">⚙️</div>
+                    </div>
+                    <div class="orbit orbit-2">
+                        <div class="orbit-node">🔧</div>
+                    </div>
+                    <div class="orbit-center">🚀</div>
+                </div>
+                <div class="feature-icon-large">⚙️</div>
+            </div>
+            <div class="feature-header-content">
+                <h3 class="feature-title-large">Text2Backend: Scalable Architecture Generator</h3>
+                <p class="feature-subtitle">Intelligent Server-Side Development</p>
+            </div>
+            <div class="feature-stats">
+                <div class="stat-item">
+                    <span class="stat-number typing-number">Database</span>
+                    <span class="stat-label">Integration</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-number typing-number">API</span>
+                    <span class="stat-label">Endpoints</span>
+                </div>
+            </div>
+        </div>
+        <div class="feature-content">
+            <div class="content-left">
+                <p class="feature-description-large">Generates efficient, scalable backend systems with database schemas, API endpoints, and microservices architecture. Uses dependency analysis to ensure scalable architecture from initial generation with comprehensive testing.</p>
+                <div class="vision-demo">
+                    <div class="demo-input">
+                        <div class="input-icon">💬</div>
+                        <div class="input-text typing">"Build a scalable e-commerce API with user authentication and payment processing"</div>
+                    </div>
+                    <div class="demo-arrow">⬇️</div>
+                    <div class="demo-output">
+                        <div class="output-items">
+                            <div class="output-item">🏗️ Microservices Architecture</div>
+                            <div class="output-item">🔒 Authentication & Security</div>
+                            <div class="output-item">🗄️ Database Schema Design</div>
+                            <div class="output-item">📊 API Documentation & Testing</div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="content-right">
+                <div class="future-timeline">
+                    <div class="timeline-item completed">
+                        <div class="timeline-marker">✅</div>
+                        <div class="timeline-content">
+                            <h4>API Design</h4>
+                            <p>RESTful endpoints</p>
+                        </div>
+                    </div>
+                    <div class="timeline-item completed">
+                        <div class="timeline-marker">✅</div>
+                        <div class="timeline-content">
+                            <h4>Database Layer</h4>
+                            <p>Schema & relationships</p>
+                        </div>
+                    </div>
+                    <div class="timeline-item active">
+                        <div class="timeline-marker">🔄</div>
+                        <div class="timeline-content">
+                            <h4>Security Layer</h4>
+                            <p>Authentication & authorization</p>
+                        </div>
+                    </div>
+                    <div class="timeline-item future">
+                        <div class="timeline-marker">🚀</div>
+                        <div class="timeline-content">
+                            <h4>Deployment</h4>
+                            <p>CI/CD integration</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+    <div class="feature-card-vertical tech">
+        <div class="card-glow-vertical"></div>
+        <div class="feature-header">
+            <div class="feature-logo-container">
+                <div class="opensource-logo">
+                    <div class="github-stars">
+                        <div class="star star-1">📄</div>
+                        <div class="star star-2">🤖</div>
+                        <div class="star star-3">⚡</div>
+                    </div>
+                    <div class="community-nodes">
+                        <div class="community-node">🧠</div>
+                        <div class="community-node">🔍</div>
+                        <div class="community-node">⚙️</div>
+                    </div>
+                </div>
+                <div class="feature-icon-large">🎯</div>
+            </div>
+            <div class="feature-header-content">
+                <h3 class="feature-title-large">CodeRAG Integration System</h3>
+                <p class="feature-subtitle">Advanced Multi-Agent Orchestration</p>
+            </div>
+            <div class="feature-stats">
+                <div class="stat-item">
+                    <span class="stat-number typing-number">Global</span>
+                    <span class="stat-label">Code Analysis</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-number typing-number">Intelligent</span>
+                    <span class="stat-label">Orchestration</span>
+                </div>
+            </div>
+        </div>
+        <div class="feature-content">
+            <div class="content-left">
+                <p class="feature-description-large">Advanced retrieval-augmented generation combining semantic vector embeddings with graph-based dependency analysis. Central orchestrating agent coordinates specialized agents with dynamic task planning and intelligent memory management.</p>
+                <div class="community-features">
+                    <div class="community-feature">
+                        <div class="feature-icon-small">🧠</div>
+                        <div class="feature-text">
+                            <h4>Intelligent Orchestration</h4>
+                            <p>Central decision-making with dynamic planning algorithms</p>
+                        </div>
+                    </div>
+                    <div class="community-feature">
+                        <div class="feature-icon-small">🔍</div>
+                        <div class="feature-text">
+                            <h4>CodeRAG System</h4>
+                            <p>Semantic analysis with dependency graph mapping</p>
+                        </div>
+                    </div>
+                    <div class="community-feature">
+                        <div class="feature-icon-small">⚡</div>
+                        <div class="feature-text">
+                            <h4>Quality Assurance</h4>
+                            <p>Automated testing, validation, and documentation</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="content-right">
+                <div class="tech-ecosystem">
+                    <div class="ecosystem-center">
+                        <div class="center-logo">🧠</div>
+                        <span>Multi-Agent Engine</span>
+                    </div>
+                    <div class="ecosystem-ring">
+                        <div class="ecosystem-item item-1">
+                            <div class="item-icon">🎯</div>
+                            <span>Central Orchestration</span>
+                        </div>
+                        <div class="ecosystem-item item-2">
+                            <div class="item-icon">📝</div>
+                            <span>Intent Understanding</span>
+                        </div>
+                        <div class="ecosystem-item item-3">
+                            <div class="item-icon">🔍</div>
+                            <span>Code Mining & Indexing</span>
+                        </div>
+                        <div class="ecosystem-item item-4">
+                            <div class="item-icon">🧬</div>
+                            <span>Code Generation</span>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+
+def display_status(message: str, status_type: str = "info"):
+    """
+    Display status message
+
+    Args:
+        message: Status message
+        status_type: Status type (success, error, warning, info)
+    """
+    status_classes = {
+        "success": "status-success",
+        "error": "status-error",
+        "warning": "status-warning",
+        "info": "status-info",
+    }
+
+    icons = {"success": "✅", "error": "❌", "warning": "⚠️", "info": "ℹ️"}
+
+    css_class = status_classes.get(status_type, "status-info")
+    icon = icons.get(status_type, "ℹ️")
+
+    st.markdown(
+        f"""
+    <div class="{css_class}">
+        {icon} {message}
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+
+def system_status_component():
+    """System status check component"""
+    st.markdown("### 🔧 System Status & Diagnostics")
+
+    # Basic system information
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("#### 📊 Environment")
+        st.info(f"**Python:** {sys.version.split()[0]}")
+        st.info(f"**Platform:** {sys.platform}")
+
+        # Check key modules
+        modules_to_check = [
+            ("streamlit", "Streamlit UI Framework"),
+            ("asyncio", "Async Processing"),
+            ("nest_asyncio", "Nested Event Loops"),
+            ("concurrent.futures", "Threading Support"),
+        ]
+
+        st.markdown("#### 📦 Module Status")
+        for module_name, description in modules_to_check:
+            try:
+                __import__(module_name)
+                st.success(f"✅ {description}")
+            except ImportError:
+                st.error(f"❌ {description} - Missing")
+
+    with col2:
+        st.markdown("#### ⚙️ Threading & Context")
+
+        # Check Streamlit context
+        try:
+            from streamlit.runtime.scriptrunner import get_script_run_ctx
+
+            ctx = get_script_run_ctx()
+            if ctx:
+                st.success("✅ Streamlit Context Available")
+            else:
+                st.warning("⚠️ Streamlit Context Not Found")
+        except Exception as e:
+            st.error(f"❌ Context Check Failed: {e}")
+
+        # Check event loop
+        try:
+            import asyncio
+
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    st.info("🔄 Event Loop Running")
+                else:
+                    st.info("⏸️ Event Loop Not Running")
+            except RuntimeError:
+                st.info("🆕 No Event Loop (Normal)")
+        except Exception as e:
+            st.error(f"❌ Event Loop Check Failed: {e}")
+
+
+def error_troubleshooting_component():
+    """Error troubleshooting component"""
+    with st.expander("🛠️ Troubleshooting Tips", expanded=False):
+        st.markdown("""
+        ### Common Issues & Solutions
+
+        #### 1. ScriptRunContext Warnings
+        - **What it means:** Threading context warnings in Streamlit
+        - **Solution:** These warnings are usually safe to ignore
+        - **Prevention:** Restart the application if persistent
+
+        #### 2. Async Processing Errors
+        - **Symptoms:** "Event loop" or "Thread" errors
+        - **Solution:** The app uses multiple fallback methods
+        - **Action:** Try refreshing the page or restarting
+
+        #### 3. File Upload Issues
+        - **Check:** File size < 200MB
+        - **Formats:** PDF, DOCX, TXT, HTML, MD
+        - **Action:** Try a different file format
+
+        #### 4. Processing Timeout
+        - **Normal:** Large papers may take 5-10 minutes
+        - **Action:** Wait patiently, check progress indicators
+        - **Limit:** 5-minute maximum processing time
+
+        #### 5. Memory Issues
+        - **Symptoms:** "Out of memory" errors
+        - **Solution:** Close other applications
+        - **Action:** Try smaller/simpler papers first
+        """)
+
+        if st.button("🔄 Reset Application State"):
+            # Clear all session state
+            for key in list(st.session_state.keys()):
+                del st.session_state[key]
+            st.success("Application state reset! Please refresh the page.")
+            st.rerun()
+
+
+def sidebar_control_panel() -> Dict[str, Any]:
+    """
+    Sidebar control panel
+
+    Returns:
+        Control panel state
+    """
+    with st.sidebar:
+        st.markdown("### 🎛️ Control Panel")
+
+        # Application status
+        if st.session_state.processing:
+            st.warning("🟡 Engine Processing...")
+        else:
+            st.info("⚪ Engine Ready")
+
+        # Workflow configuration options
+        st.markdown("### ⚙️ Workflow Settings")
+
+        # Indexing functionality toggle
+        enable_indexing = st.checkbox(
+            "🗂️ Enable Codebase Indexing",
+            value=True,
+            help="Enable GitHub repository download and codebase indexing. Disabling this will skip Phase 6 (GitHub Download) and Phase 7 (Codebase Indexing) for faster processing.",
+            key="enable_indexing",
+        )
+
+        if enable_indexing:
+            st.success("✅ Full workflow with indexing enabled")
+        else:
+            st.info("⚡ Fast mode - indexing disabled")
+
+        # System information
+        st.markdown("### 📊 System Info")
+        st.info(f"**Python:** {sys.version.split()[0]}")
+        st.info(f"**Platform:** {sys.platform}")
+
+        # Add system status check
+        with st.expander("🔧 System Status"):
+            system_status_component()
+
+        # Add error diagnostics
+        error_troubleshooting_component()
+
+        st.markdown("---")
+
+        # Processing history
+        history_info = display_processing_history()
+
+        return {
+            "processing": st.session_state.processing,
+            "history_count": history_info["count"],
+            "has_history": history_info["has_history"],
+            "enable_indexing": enable_indexing,  # Add indexing toggle state
+        }
+
+
+def display_processing_history() -> Dict[str, Any]:
+    """
+    Display processing history
+
+    Returns:
+        History information
+    """
+    st.markdown("### 📊 Processing History")
+
+    has_history = bool(st.session_state.results)
+    history_count = len(st.session_state.results)
+
+    if has_history:
+        # Only show last 10 records
+        recent_results = st.session_state.results[-10:]
+        for i, result in enumerate(reversed(recent_results)):
+            status_icon = "✅" if result.get("status") == "success" else "❌"
+            with st.expander(
+                f"{status_icon} Task - {result.get('timestamp', 'Unknown')}"
+            ):
+                st.write(f"**Status:** {result.get('status', 'Unknown')}")
+                if result.get("input_type"):
+                    st.write(f"**Type:** {result['input_type']}")
+                if result.get("error"):
+                    st.error(f"Error: {result['error']}")
+    else:
+        st.info("No processing history yet")
+
+    # Clear history button
+    if has_history:
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("🗑️ Clear History", use_container_width=True):
+                st.session_state.results = []
+                st.rerun()
+        with col2:
+            st.info(f"Total: {history_count} tasks")
+
+    return {"has_history": has_history, "count": history_count}
+
+
+def file_input_component(task_counter: int) -> Optional[str]:
+    """
+    File input component with automatic PDF conversion
+
+    Args:
+        task_counter: Task counter
+
+    Returns:
+        PDF file path or None
+    """
+    uploaded_file = st.file_uploader(
+        "Upload research paper file",
+        type=[
+            "pdf",
+            "docx",
+            "doc",
+            "ppt",
+            "pptx",
+            "xls",
+            "xlsx",
+            "html",
+            "htm",
+            "txt",
+            "md",
+        ],
+        help="Supported formats: PDF, Word, PowerPoint, Excel, HTML, Text (all files will be converted to PDF)",
+        key=f"file_uploader_{task_counter}",
+    )
+
+    if uploaded_file is not None:
+        # Display file information
+        file_size = len(uploaded_file.getvalue())
+        st.info(f"📄 **File:** {uploaded_file.name} ({format_file_size(file_size)})")
+
+        # Save uploaded file to temporary directory
+        try:
+            import tempfile
+            import sys
+            import os
+            from pathlib import Path
+
+            # Add project root to path for imports
+            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))
+
+            # Import PDF converter
+            from tools.pdf_converter import PDFConverter
+
+            # Save original file
+            file_ext = uploaded_file.name.split(".")[-1].lower()
+            with tempfile.NamedTemporaryFile(
+                delete=False, suffix=f".{file_ext}"
+            ) as tmp_file:
+                tmp_file.write(uploaded_file.getvalue())
+                original_file_path = tmp_file.name
+
+            st.success("✅ File uploaded successfully!")
+
+            # Check if file is already PDF
+            if file_ext == "pdf":
+                st.info("📑 File is already in PDF format, no conversion needed.")
+                return original_file_path
+
+            # Convert to PDF
+            with st.spinner(f"🔄 Converting {file_ext.upper()} to PDF..."):
+                try:
+                    converter = PDFConverter()
+
+                    # Check dependencies
+                    deps = converter.check_dependencies()
+                    missing_deps = []
+
+                    if (
+                        file_ext in {"doc", "docx", "ppt", "pptx", "xls", "xlsx"}
+                        and not deps["libreoffice"]
+                    ):
+                        missing_deps.append("LibreOffice")
+
+                    if file_ext in {"txt", "md"} and not deps["reportlab"]:
+                        missing_deps.append("ReportLab")
+
+                    if missing_deps:
+                        st.error(f"❌ Missing dependencies: {', '.join(missing_deps)}")
+                        st.info("💡 Please install the required dependencies:")
+                        if "LibreOffice" in missing_deps:
+                            st.code(
+                                "# Install LibreOffice\n"
+                                "# Windows: Download from https://www.libreoffice.org/\n"
+                                "# macOS: brew install --cask libreoffice\n"
+                                "# Ubuntu: sudo apt-get install libreoffice"
+                            )
+                        if "ReportLab" in missing_deps:
+                            st.code("pip install reportlab")
+
+                        # Clean up original file
+                        try:
+                            os.unlink(original_file_path)
+                        except Exception:
+                            pass
+                        return None
+
+                    # Perform conversion
+                    pdf_path = converter.convert_to_pdf(original_file_path)
+
+                    # Clean up original file
+                    try:
+                        os.unlink(original_file_path)
+                    except Exception:
+                        pass
+
+                    # Display conversion result
+                    pdf_size = Path(pdf_path).stat().st_size
+                    st.success("✅ Successfully converted to PDF!")
+                    st.info(
+                        f"📑 **PDF File:** {Path(pdf_path).name} ({format_file_size(pdf_size)})"
+                    )
+
+                    return str(pdf_path)
+
+                except Exception as e:
+                    st.error(f"❌ PDF conversion failed: {str(e)}")
+                    st.warning("💡 You can try:")
+                    st.markdown("- Converting the file to PDF manually")
+                    st.markdown("- Using a different file format")
+                    st.markdown("- Checking if the file is corrupted")
+
+                    # Clean up original file
+                    try:
+                        os.unlink(original_file_path)
+                    except Exception:
+                        pass
+                    return None
+
+        except Exception as e:
+            st.error(f"❌ Failed to process uploaded file: {str(e)}")
+            return None
+
+    return None
+
+
+def url_input_component(task_counter: int) -> Optional[str]:
+    """
+    URL input component
+
+    Args:
+        task_counter: Task counter
+
+    Returns:
+        URL or None
+    """
+    url_input = st.text_input(
+        "Enter paper URL",
+        placeholder="https://arxiv.org/abs/..., https://ieeexplore.ieee.org/..., etc.",
+        help="Enter a direct link to a research paper (arXiv, IEEE, ACM, etc.)",
+        key=f"url_input_{task_counter}",
+    )
+
+    if url_input:
+        # Simple URL validation
+        if url_input.startswith(("http://", "https://")):
+            st.success(f"✅ URL entered: {url_input}")
+            return url_input
+        else:
+            st.warning("⚠️ Please enter a valid URL starting with http:// or https://")
+            return None
+
+    return None
+
+
+def chat_input_component(task_counter: int) -> Optional[str]:
+    """
+    Chat input component for coding requirements
+
+    Args:
+        task_counter: Task counter
+
+    Returns:
+        User coding requirements or None
+    """
+    st.markdown(
+        """
+    <div style="background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
+                border-radius: 10px;
+                padding: 15px;
+                margin-bottom: 20px;
+                border-left: 4px solid #4dd0e1;">
+        <h4 style="color: white; margin: 0 0 10px 0; font-size: 1.1rem;">
+            💬 Describe Your Coding Requirements
+        </h4>
+        <p style="color: #e0f7fa; margin: 0; font-size: 0.9rem;">
+            Tell us what you want to build. Our AI will analyze your requirements and generate a comprehensive implementation plan.
+        </p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Examples to help users understand what they can input
+    with st.expander("💡 See Examples", expanded=False):
+        st.markdown("""
+        **Academic Research Examples:**
+        - "I need to implement a reinforcement learning algorithm for robotic control"
+        - "Create a neural network for image classification with attention mechanisms"
+        - "Build a natural language processing pipeline for sentiment analysis"
+
+        **Engineering Project Examples:**
+        - "Develop a web application for project management with user authentication"
+        - "Create a data visualization dashboard for sales analytics"
+        - "Build a REST API for a e-commerce platform with database integration"
+
+        **Mixed Project Examples:**
+        - "Implement a machine learning model with a web interface for real-time predictions"
+        - "Create a research tool with user-friendly GUI for data analysis"
+        - "Build a chatbot with both academic evaluation metrics and production deployment"
+        """)
+
+    # Main text area for user input
+    user_input = st.text_area(
+        "Enter your coding requirements:",
+        placeholder="""Example: I want to build a web application that can analyze user sentiment from social media posts. The application should have:
+
+1. A user-friendly interface where users can input text or upload files
+2. A machine learning backend that performs sentiment analysis
+3. Visualization of results with charts and statistics
+4. User authentication and data storage
+5. REST API for integration with other applications
+
+The system should be scalable and production-ready, with proper error handling and documentation.""",
+        height=200,
+        help="Describe what you want to build, including functionality, technologies, and any specific requirements",
+        key=f"chat_input_{task_counter}",
+    )
+
+    if user_input and len(user_input.strip()) > 20:  # Minimum length check
+        # Display input summary
+        word_count = len(user_input.split())
+        char_count = len(user_input)
+
+        st.success(
+            f"✅ **Requirements captured!** ({word_count} words, {char_count} characters)"
+        )
+
+        # Show a preview of what will be analyzed
+        with st.expander("📋 Preview your requirements", expanded=False):
+            st.text_area(
+                "Your input:",
+                user_input,
+                height=100,
+                disabled=True,
+                key=f"preview_{task_counter}",
+            )
+
+        return user_input.strip()
+
+    elif user_input and len(user_input.strip()) <= 20:
+        st.warning(
+            "⚠️ Please provide more detailed requirements (at least 20 characters)"
+        )
+        return None
+
+    return None
+
+
+def input_method_selector(task_counter: int) -> tuple[Optional[str], Optional[str]]:
+    """
+    Input method selector
+
+    Args:
+        task_counter: Task counter
+
+    Returns:
+        (input_source, input_type)
+    """
+    st.markdown(
+        """
+    <h3 style="color: var(--text-primary) !important; font-family: 'Inter', sans-serif !important; font-weight: 600 !important; font-size: 1.5rem !important; margin-bottom: 1rem !important;">
+        🚀 Start Processing
+    </h3>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Input options
+    st.markdown(
+        """
+    <p style="color: var(--text-secondary) !important; font-family: 'Inter', sans-serif !important; font-weight: 500 !important; margin-bottom: 1rem !important;">
+        Choose input method:
+    </p>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    input_method = st.radio(
+        "Choose your input method:",
+        ["📁 Upload File", "🌐 Enter URL", "💬 Chat Input"],
+        horizontal=True,
+        label_visibility="hidden",
+        key=f"input_method_{task_counter}",
+    )
+
+    input_source = None
+    input_type = None
+
+    if input_method == "📁 Upload File":
+        input_source = file_input_component(task_counter)
+        input_type = "file" if input_source else None
+    elif input_method == "🌐 Enter URL":
+        input_source = url_input_component(task_counter)
+        input_type = "url" if input_source else None
+    else:  # Chat input
+        input_source = chat_input_component(task_counter)
+        input_type = "chat" if input_source else None
+
+    return input_source, input_type
+
+
+def results_display_component(result: Dict[str, Any], task_counter: int):
+    """
+    Results display component
+
+    Args:
+        result: Processing result
+        task_counter: Task counter
+    """
+    st.markdown("### 📋 Processing Results")
+
+    # Display overall status
+    if result.get("status") == "success":
+        st.success("🎉 **All workflows completed successfully!**")
+    else:
+        st.error("❌ **Processing encountered errors**")
+
+    # Create tabs to organize different phase results
+    tab1, tab2, tab3, tab4 = st.tabs(
+        [
+            "📊 Analysis Phase",
+            "📥 Download Phase",
+            "🔧 Implementation Phase",
+            "📁 Generated Files",
+        ]
+    )
+
+    with tab1:
+        st.markdown("#### 📊 Paper Analysis Results")
+        with st.expander("Analysis Output Details", expanded=True):
+            analysis_result = result.get(
+                "analysis_result", "No analysis result available"
+            )
+            try:
+                # Try to parse JSON result for formatted display
+                if analysis_result.strip().startswith("{"):
+                    parsed_analysis = json.loads(analysis_result)
+                    st.json(parsed_analysis)
+                else:
+                    st.text_area(
+                        "Raw Analysis Output",
+                        analysis_result,
+                        height=300,
+                        key=f"analysis_{task_counter}",
+                    )
+            except Exception:
+                st.text_area(
+                    "Analysis Output",
+                    analysis_result,
+                    height=300,
+                    key=f"analysis_{task_counter}",
+                )
+
+    with tab2:
+        st.markdown("#### 📥 Download & Preparation Results")
+        with st.expander("Download Process Details", expanded=True):
+            download_result = result.get(
+                "download_result", "No download result available"
+            )
+            st.text_area(
+                "Download Output",
+                download_result,
+                height=300,
+                key=f"download_{task_counter}",
+            )
+
+            # Try to extract file path information
+            if "paper_dir" in download_result or "path" in download_result.lower():
+                st.info(
+                    "💡 **Tip:** Look for file paths in the output above to locate generated files"
+                )
+
+    with tab3:
+        st.markdown("#### 🔧 Code Implementation Results")
+        repo_result = result.get("repo_result", "No implementation result available")
+
+        # Analyze implementation results to extract key information
+        if "successfully" in repo_result.lower():
+            st.success("✅ Code implementation completed successfully!")
+        elif "failed" in repo_result.lower():
+            st.warning("⚠️ Code implementation encountered issues")
+        else:
+            st.info("ℹ️ Code implementation status unclear")
+
+        with st.expander("Implementation Details", expanded=True):
+            st.text_area(
+                "Repository & Code Generation Output",
+                repo_result,
+                height=300,
+                key=f"repo_{task_counter}",
+            )
+
+        # Try to extract generated code directory information
+        if "Code generated in:" in repo_result:
+            code_dir = repo_result.split("Code generated in:")[-1].strip()
+            st.markdown(f"**📁 Generated Code Directory:** `{code_dir}`")
+
+        # Display workflow stage details
+        st.markdown("#### 🔄 Workflow Stages Completed")
+        stages = [
+            ("📄 Document Processing", "✅"),
+            ("🔍 Reference Analysis", "✅"),
+            ("📋 Plan Generation", "✅"),
+            ("📦 Repository Download", "✅"),
+            ("🗂️ Codebase Indexing", "✅" if "indexing" in repo_result.lower() else "⚠️"),
+            (
+                "⚙️ Code Implementation",
+                "✅" if "successfully" in repo_result.lower() else "⚠️",
+            ),
+        ]
+
+        for stage_name, status in stages:
+            st.markdown(f"- {stage_name}: {status}")
+
+    with tab4:
+        st.markdown("#### 📁 Generated Files & Reports")
+
+        # Try to extract file paths from results
+        all_results = (
+            f"{result.get('download_result', '')} {result.get('repo_result', '')}"
+        )
+
+        # Look for possible file path patterns
+        import re
+
+        file_patterns = [
+            r"([^\s]+\.txt)",
+            r"([^\s]+\.json)",
+            r"([^\s]+\.py)",
+            r"([^\s]+\.md)",
+            r"paper_dir[:\s]+([^\s]+)",
+            r"saved to ([^\s]+)",
+            r"generated in[:\s]+([^\s]+)",
+        ]
+
+        found_files = set()
+        for pattern in file_patterns:
+            matches = re.findall(pattern, all_results, re.IGNORECASE)
+            for match in matches:
+                if isinstance(match, tuple):
+                    found_files.update(match)
+                else:
+                    found_files.add(match)
+
+        if found_files:
+            st.markdown("**📄 Detected Generated Files:**")
+            for file_path in sorted(found_files):
+                if file_path and len(file_path) > 3:  # Filter out too short matches
+                    st.markdown(f"- `{file_path}`")
+        else:
+            st.info(
+                "No specific file paths detected in the output. Check the detailed results above for file locations."
+            )
+
+        # Provide option to view raw results
+        with st.expander("View Raw Processing Results"):
+            st.json(
+                {
+                    "analysis_result": result.get("analysis_result", ""),
+                    "download_result": result.get("download_result", ""),
+                    "repo_result": result.get("repo_result", ""),
+                    "status": result.get("status", "unknown"),
+                }
+            )
+
+    # Action buttons
+    st.markdown("---")
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("🔄 Process New Paper", type="primary", use_container_width=True):
+            st.session_state.show_results = False
+            st.session_state.last_result = None
+            st.session_state.last_error = None
+            st.session_state.task_counter += 1
+            st.rerun()
+
+    with col2:
+        if st.button("💾 Export Results", type="secondary", use_container_width=True):
+            # Create result export
+            export_data = {
+                "timestamp": datetime.now().isoformat(),
+                "processing_results": result,
+                "status": result.get("status", "unknown"),
+            }
+            st.download_button(
+                label="📄 Download Results JSON",
+                data=json.dumps(export_data, indent=2, ensure_ascii=False),
+                file_name=f"paper_processing_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                mime="application/json",
+                use_container_width=True,
+            )
+
+
+def progress_display_component():
+    """
+    Progress display component
+
+    Returns:
+        (progress_bar, status_text)
+    """
+    # Display processing progress title
+    st.markdown("### 📊 Processing Progress")
+
+    # Create progress container
+    progress_container = st.container()
+
+    with progress_container:
+        # Add custom CSS styles
+        st.markdown(
+            """
+        <style>
+        .progress-container {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            border-radius: 15px;
+            padding: 20px;
+            margin: 10px 0;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+        }
+        .progress-steps {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 15px;
+            flex-wrap: wrap;
+        }
+        .progress-step {
+            background: rgba(255,255,255,0.1);
+            border-radius: 10px;
+            padding: 8px 12px;
+            margin: 2px;
+            color: white;
+            font-size: 0.8rem;
+            font-weight: 500;
+            border: 2px solid transparent;
+            transition: all 0.3s ease;
+        }
+        .progress-step.active {
+            background: rgba(255,255,255,0.3);
+            border-color: #00ff88;
+            box-shadow: 0 0 15px rgba(0,255,136,0.3);
+        }
+        .progress-step.completed {
+            background: rgba(0,255,136,0.2);
+            border-color: #00ff88;
+        }
+        .status-text {
+            color: white;
+            font-weight: 600;
+            font-size: 1.1rem;
+            margin: 10px 0;
+            text-align: center;
+        }
+        </style>
+        """,
+            unsafe_allow_html=True,
+        )
+
+        st.markdown('<div class="progress-container">', unsafe_allow_html=True)
+
+        # Create step indicator
+        st.markdown(
+            """
+        <div class="progress-steps">
+            <div class="progress-step" id="step-init">🚀 Initialize</div>
+            <div class="progress-step" id="step-analyze">📊 Analyze</div>
+            <div class="progress-step" id="step-download">📥 Download</div>
+            <div class="progress-step" id="step-references">🔍 References</div>
+            <div class="progress-step" id="step-plan">📋 Plan</div>
+            <div class="progress-step" id="step-repos">📦 Repos</div>
+            <div class="progress-step" id="step-index">🗂️ Index</div>
+            <div class="progress-step" id="step-implement">⚙️ Implement</div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+        # Create progress bar and status text
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+
+        st.markdown("</div>", unsafe_allow_html=True)
+
+    return progress_bar, status_text
+
+
+def enhanced_progress_display_component(
+    enable_indexing: bool = True, chat_mode: bool = False
+):
+    """
+    Enhanced progress display component
+
+    Args:
+        enable_indexing: Whether indexing is enabled
+        chat_mode: Whether in chat mode (user requirements input)
+
+    Returns:
+        (progress_bar, status_text, step_indicator, workflow_steps)
+    """
+    # Display processing progress title
+    if chat_mode:
+        st.markdown("### 💬 AI Chat Planning - Requirements to Code Workflow")
+    elif enable_indexing:
+        st.markdown("### 🚀 AI Research Engine - Full Processing Workflow")
+    else:
+        st.markdown(
+            "### ⚡ AI Research Engine - Fast Processing Workflow (Indexing Disabled)"
+        )
+
+    # Create progress container
+    progress_container = st.container()
+
+    with progress_container:
+        # Workflow step definitions - adjust based on mode and indexing toggle
+        if chat_mode:
+            # Chat mode - simplified workflow for user requirements
+            workflow_steps = [
+                ("🚀", "Initialize", "Setting up chat engine"),
+                ("💬", "Planning", "Analyzing requirements"),
+                ("🏗️", "Setup", "Creating workspace"),
+                ("📝", "Save Plan", "Saving implementation plan"),
+                ("⚙️", "Implement", "Generating code"),
+            ]
+        elif enable_indexing:
+            workflow_steps = [
+                ("🚀", "Initialize", "Setting up AI engine"),
+                ("📊", "Analyze", "Analyzing paper content"),
+                ("📥", "Download", "Processing document"),
+                (
+                    "📋",
+                    "Plan",
+                    "Generating code plan",
+                ),  # Phase 3: code planning orchestration
+                (
+                    "🔍",
+                    "References",
+                    "Analyzing references",
+                ),  # Phase 4: now conditional
+                ("📦", "Repos", "Downloading repositories"),  # Phase 5: GitHub download
+                ("🗂️", "Index", "Building code index"),  # Phase 6: code indexing
+                ("⚙️", "Implement", "Implementing code"),  # Phase 7: code implementation
+            ]
+        else:
+            # Fast mode - skip References, Repos and Index steps
+            workflow_steps = [
+                ("🚀", "Initialize", "Setting up AI engine"),
+                ("📊", "Analyze", "Analyzing paper content"),
+                ("📥", "Download", "Processing document"),
+                (
+                    "📋",
+                    "Plan",
+                    "Generating code plan",
+                ),  # Phase 3: code planning orchestration
+                (
+                    "⚙️",
+                    "Implement",
+                    "Implementing code",
+                ),  # Jump directly to implementation
+            ]
+
+        # Display step grid with fixed layout
+        # Use a maximum of 8 columns for consistent sizing
+        max_cols = 8
+        cols = st.columns(max_cols)
+        step_indicators = []
+
+        # Calculate column spacing for centering steps
+        total_steps = len(workflow_steps)
+        if total_steps <= max_cols:
+            # Center the steps when fewer than max columns
+            start_col = (max_cols - total_steps) // 2
+        else:
+            start_col = 0
+
+        for i, (icon, title, desc) in enumerate(workflow_steps):
+            col_index = start_col + i if total_steps <= max_cols else i
+            if col_index < max_cols:
+                with cols[col_index]:
+                    step_placeholder = st.empty()
+                    step_indicators.append(step_placeholder)
+                    step_placeholder.markdown(
+                        f"""
+                    <div style="
+                        text-align: center;
+                        padding: 12px 8px;
+                        border-radius: 12px;
+                        background: rgba(255,255,255,0.05);
+                        margin: 5px 2px;
+                        border: 2px solid transparent;
+                        min-height: 90px;
+                        display: flex;
+                        flex-direction: column;
+                        justify-content: center;
+                        align-items: center;
+                        box-sizing: border-box;
+                    ">
+                        <div style="font-size: 1.5rem; margin-bottom: 4px;">{icon}</div>
+                        <div style="font-size: 0.75rem; font-weight: 600; line-height: 1.2; margin-bottom: 2px;">{title}</div>
+                        <div style="font-size: 0.6rem; color: #888; line-height: 1.1; text-align: center;">{desc}</div>
+                    </div>
+                    """,
+                        unsafe_allow_html=True,
+                    )
+
+        # Create main progress bar
+        st.markdown("#### Overall Progress")
+        progress_bar = st.progress(0)
+
+        # Status text display
+        status_text = st.empty()
+
+        # Display mode information
+        if not enable_indexing:
+            st.info(
+                "⚡ Fast Mode: Reference analysis, GitHub repository download and codebase indexing are disabled for faster processing."
+            )
+
+    return progress_bar, status_text, step_indicators, workflow_steps
+
+
+def update_step_indicator(
+    step_indicators, workflow_steps, current_step: int, status: str = "active"
+):
+    """
+    Update step indicator
+
+    Args:
+        step_indicators: Step indicator list
+        workflow_steps: Workflow steps definition
+        current_step: Current step index
+        status: Status ("active", "completed", "error")
+    """
+    status_colors = {
+        "pending": ("rgba(255,255,255,0.05)", "transparent", "#888"),
+        "active": ("rgba(255,215,0,0.2)", "#ffd700", "#fff"),
+        "completed": ("rgba(0,255,136,0.2)", "#00ff88", "#fff"),
+        "error": ("rgba(255,99,99,0.2)", "#ff6363", "#fff"),
+    }
+
+    for i, (icon, title, desc) in enumerate(workflow_steps):
+        if i < current_step:
+            bg_color, border_color, text_color = status_colors["completed"]
+            display_icon = "✅"
+        elif i == current_step:
+            bg_color, border_color, text_color = status_colors[status]
+            display_icon = icon
+        else:
+            bg_color, border_color, text_color = status_colors["pending"]
+            display_icon = icon
+
+        step_indicators[i].markdown(
+            f"""
+        <div style="
+            text-align: center;
+            padding: 12px 8px;
+            border-radius: 12px;
+            background: {bg_color};
+            margin: 5px 2px;
+            border: 2px solid {border_color};
+            color: {text_color};
+            transition: all 0.3s ease;
+            box-shadow: {f'0 0 15px {border_color}30' if i == current_step else 'none'};
+            min-height: 90px;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            box-sizing: border-box;
+        ">
+            <div style="font-size: 1.5rem; margin-bottom: 4px;">{display_icon}</div>
+            <div style="font-size: 0.75rem; font-weight: 600; line-height: 1.2; margin-bottom: 2px;">{title}</div>
+            <div style="font-size: 0.6rem; opacity: 0.8; line-height: 1.1; text-align: center;">{desc}</div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+
+def footer_component():
+    """Footer component"""
+    st.markdown("---")
+    st.markdown(
+        """
+    <div style="text-align: center; color: #666; padding: 2rem;">
+        <p>🧬 <strong>DeepCode</strong> | Open-Source Code Agent | Data Intelligence Lab @ HKU |
+        <a href="https://github.com/your-repo" target="_blank" style="color: var(--neon-blue);">GitHub</a></p>
+        <p>⚡ Revolutionizing Research Reproducibility • Multi-Agent Architecture • Automated Code Generation</p>
+        <p><small>💡 Join our growing community in building the future of automated research reproducibility</small></p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+
+def format_file_size(size_bytes: int) -> str:
+    """
+    Format file size
+
+    Args:
+        size_bytes: Size in bytes
+
+    Returns:
+        Formatted file size
+    """
+    if size_bytes == 0:
+        return "0B"
+    size_names = ["B", "KB", "MB", "GB"]
+    i = 0
+    while size_bytes >= 1024 and i < len(size_names) - 1:
+        size_bytes /= 1024.0
+        i += 1
+    return f"{size_bytes:.1f}{size_names[i]}"

projects/ui/DeepCode/ui/handlers.py

@@ -0,0 +1,773 @@
+"""
+Streamlit Event Handlers Module
+
+Contains all event handling and business logic
+"""
+
+import asyncio
+import time
+import os
+import traceback
+import atexit
+import signal
+from datetime import datetime
+from typing import Dict, Any
+
+import streamlit as st
+import nest_asyncio
+import concurrent.futures
+
+# Import necessary modules
+from mcp_agent.app import MCPApp
+from workflows.agent_orchestration_engine import (
+    execute_multi_agent_research_pipeline,
+    execute_chat_based_planning_pipeline,
+)
+
+
+def _emergency_cleanup():
+    """
+    Emergency resource cleanup function
+    Called when program exits abnormally
+    """
+    try:
+        cleanup_resources()
+    except Exception:
+        pass  # Silent handling to avoid new exceptions during exit
+
+
+def _signal_handler(signum, frame):
+    """
+    Signal handler for program termination signals
+    """
+    try:
+        cleanup_resources()
+    except Exception:
+        pass
+    finally:
+        # Restore default signal handling and resend signal
+        signal.signal(signum, signal.SIG_DFL)
+        os.kill(os.getpid(), signum)
+
+
+# Register exit cleanup function
+atexit.register(_emergency_cleanup)
+
+
+def _safe_register_signal_handlers():
+    """Safely register signal handlers"""
+    try:
+        # Check if running in main thread
+        import threading
+
+        if threading.current_thread() is not threading.main_thread():
+            return  # Signal handlers can only be registered in main thread
+
+        # Try to register signal handlers
+        signal.signal(signal.SIGTERM, _signal_handler)
+        signal.signal(signal.SIGINT, _signal_handler)
+        if hasattr(signal, "SIGBREAK"):  # Windows
+            signal.signal(signal.SIGBREAK, _signal_handler)
+    except (AttributeError, OSError, ValueError):
+        # Some signals are not available on certain platforms or disabled in some environments
+        # This is common in web frameworks like Streamlit
+        pass
+
+
+# Delayed signal handler registration to avoid import-time errors
+try:
+    _safe_register_signal_handlers()
+except Exception:
+    # If registration fails, silently ignore and don't affect app startup
+    pass
+
+
+async def process_input_async(
+    input_source: str,
+    input_type: str,
+    enable_indexing: bool = True,
+    progress_callback=None,
+) -> Dict[str, Any]:
+    """
+    Process input asynchronously
+
+    Args:
+        input_source: Input source
+        input_type: Input type
+        enable_indexing: Whether to enable indexing functionality
+        progress_callback: Progress callback function
+
+    Returns:
+        Processing result
+    """
+    try:
+        # Create and use MCP app in the same async context
+        app = MCPApp(name="paper_to_code")
+
+        async with app.run() as agent_app:
+            logger = agent_app.logger
+            context = agent_app.context
+            context.config.mcp.servers["filesystem"].args.extend([os.getcwd()])
+
+            # Initialize progress
+            if progress_callback:
+                if input_type == "chat":
+                    progress_callback(
+                        5, "🚀 Initializing chat-based planning pipeline..."
+                    )
+                else:
+                    progress_callback(5, "🚀 Initializing AI research engine...")
+
+            # Choose pipeline based on input type
+            if input_type == "chat":
+                # Use chat-based planning pipeline for user requirements
+                repo_result = await execute_chat_based_planning_pipeline(
+                    input_source,  # User's coding requirements
+                    logger,
+                    progress_callback,
+                    enable_indexing=enable_indexing,  # Pass indexing control parameter
+                )
+            else:
+                # Use traditional multi-agent research pipeline for files/URLs
+                repo_result = await execute_multi_agent_research_pipeline(
+                    input_source,
+                    logger,
+                    progress_callback,
+                    enable_indexing=enable_indexing,  # Pass indexing control parameter
+                )
+
+            return {
+                "analysis_result": "Integrated into complete workflow",
+                "download_result": "Integrated into complete workflow",
+                "repo_result": repo_result,
+                "status": "success",
+            }
+
+    except Exception as e:
+        error_msg = str(e)
+        traceback_msg = traceback.format_exc()
+
+        return {"error": error_msg, "traceback": traceback_msg, "status": "error"}
+
+
+def run_async_task(coro):
+    """
+    Helper function to run async tasks
+
+    Args:
+        coro: Coroutine object
+
+    Returns:
+        Task result
+    """
+    # Apply nest_asyncio to support nested event loops
+    nest_asyncio.apply()
+
+    # Save current Streamlit context
+    try:
+        from streamlit.runtime.scriptrunner import get_script_run_ctx
+        from streamlit.runtime.scriptrunner.script_run_context import (
+            SCRIPT_RUN_CONTEXT_ATTR_NAME,
+        )
+
+        current_ctx = get_script_run_ctx()
+        context_available = True
+    except ImportError:
+        # If Streamlit context modules can't be imported, use fallback method
+        current_ctx = None
+        context_available = False
+
+    def run_in_new_loop():
+        """Run coroutine in new event loop"""
+        # Set Streamlit context in new thread (if available)
+        if context_available and current_ctx:
+            try:
+                import threading
+
+                setattr(
+                    threading.current_thread(),
+                    SCRIPT_RUN_CONTEXT_ATTR_NAME,
+                    current_ctx,
+                )
+            except Exception:
+                pass  # Ignore context setting errors
+
+        loop = None
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            result = loop.run_until_complete(coro)
+            return result
+        except Exception as e:
+            raise e
+        finally:
+            # Clean up resources
+            if loop:
+                try:
+                    loop.close()
+                except Exception:
+                    pass
+            asyncio.set_event_loop(None)
+
+            # Clean up thread context (if available)
+            if context_available:
+                try:
+                    import threading
+
+                    if hasattr(
+                        threading.current_thread(), SCRIPT_RUN_CONTEXT_ATTR_NAME
+                    ):
+                        delattr(
+                            threading.current_thread(), SCRIPT_RUN_CONTEXT_ATTR_NAME
+                        )
+                except Exception:
+                    pass  # Ignore cleanup errors
+
+            # Force garbage collection
+            import gc
+
+            gc.collect()
+
+    # Use thread pool to run async task, avoiding event loop conflicts
+    executor = None
+    try:
+        executor = concurrent.futures.ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="deepcode_ctx_async"
+        )
+        future = executor.submit(run_in_new_loop)
+        result = future.result(timeout=300)  # 5 minute timeout
+        return result
+    except concurrent.futures.TimeoutError:
+        st.error("Processing timeout after 5 minutes. Please try again.")
+        raise TimeoutError("Processing timeout")
+    except Exception as e:
+        # If thread pool execution fails, try direct execution
+        st.warning(f"Threaded async execution failed: {e}, trying direct execution...")
+        try:
+            # Fallback method: run directly in current thread
+            loop = None
+            try:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                result = loop.run_until_complete(coro)
+                return result
+            finally:
+                if loop:
+                    try:
+                        loop.close()
+                    except Exception:
+                        pass
+                asyncio.set_event_loop(None)
+                import gc
+
+                gc.collect()
+        except Exception as backup_error:
+            st.error(f"All execution methods failed: {backup_error}")
+            raise backup_error
+    finally:
+        # Ensure thread pool is properly closed
+        if executor:
+            try:
+                executor.shutdown(wait=True, cancel_futures=True)
+            except Exception:
+                pass
+        # Force garbage collection
+        import gc
+
+        gc.collect()
+
+
+def run_async_task_simple(coro):
+    """
+    Simple async task runner, avoiding threading issues
+
+    Args:
+        coro: Coroutine object
+
+    Returns:
+        Task result
+    """
+    # Apply nest_asyncio to support nested event loops
+    nest_asyncio.apply()
+
+    try:
+        # Try to run in current event loop
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If current loop is running, use improved thread pool method
+            import concurrent.futures
+            import gc
+
+            def run_in_thread():
+                # Create new event loop and set as current thread's loop
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+                try:
+                    result = new_loop.run_until_complete(coro)
+                    return result
+                except Exception as e:
+                    # Ensure exception information is properly passed
+                    raise e
+                finally:
+                    # Ensure loop is properly closed
+                    try:
+                        new_loop.close()
+                    except Exception:
+                        pass
+                    # Clear current thread's event loop reference
+                    asyncio.set_event_loop(None)
+                    # Force garbage collection
+                    gc.collect()
+
+            # Use context manager to ensure thread pool is properly closed
+            executor = None
+            try:
+                executor = concurrent.futures.ThreadPoolExecutor(
+                    max_workers=1, thread_name_prefix="deepcode_async"
+                )
+                future = executor.submit(run_in_thread)
+                result = future.result(timeout=300)  # 5 minute timeout
+                return result
+            except concurrent.futures.TimeoutError:
+                st.error(
+                    "Processing timeout after 5 minutes. Please try again with a smaller file."
+                )
+                raise TimeoutError("Processing timeout")
+            except Exception as e:
+                st.error(f"Async processing error: {e}")
+                raise e
+            finally:
+                # Ensure thread pool is properly closed
+                if executor:
+                    try:
+                        executor.shutdown(wait=True, cancel_futures=True)
+                    except Exception:
+                        pass
+                # Force garbage collection
+                gc.collect()
+        else:
+            # Run directly in current loop
+            return loop.run_until_complete(coro)
+    except Exception:
+        # Final fallback method: create new event loop
+        loop = None
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            result = loop.run_until_complete(coro)
+            return result
+        except Exception as backup_error:
+            st.error(f"All async methods failed: {backup_error}")
+            raise backup_error
+        finally:
+            if loop:
+                try:
+                    loop.close()
+                except Exception:
+                    pass
+            asyncio.set_event_loop(None)
+            # Force garbage collection
+            import gc
+
+            gc.collect()
+
+
+def handle_processing_workflow(
+    input_source: str, input_type: str, enable_indexing: bool = True
+) -> Dict[str, Any]:
+    """
+    Main processing function for workflow
+
+    Args:
+        input_source: Input source
+        input_type: Input type
+        enable_indexing: Whether to enable indexing functionality
+
+    Returns:
+        Processing result
+    """
+    from .components import (
+        enhanced_progress_display_component,
+        update_step_indicator,
+        display_status,
+    )
+
+    # Display enhanced progress components
+    chat_mode = input_type == "chat"
+    progress_bar, status_text, step_indicators, workflow_steps = (
+        enhanced_progress_display_component(enable_indexing, chat_mode)
+    )
+
+    # Step mapping: map progress percentages to step indices - adjust based on mode and indexing toggle
+    if chat_mode:
+        # Chat mode step mapping: Initialize -> Planning -> Setup -> Save Plan -> Implement
+        step_mapping = {
+            5: 0,  # Initialize
+            30: 1,  # Planning (analyzing requirements)
+            50: 2,  # Setup (creating workspace)
+            70: 3,  # Save Plan (saving implementation plan)
+            85: 4,  # Implement (generating code)
+            100: 4,  # Complete
+        }
+    elif not enable_indexing:
+        # Skip indexing-related steps progress mapping - fast mode order: Initialize -> Analyze -> Download -> Plan -> Implement
+        step_mapping = {
+            5: 0,  # Initialize
+            10: 1,  # Analyze
+            25: 2,  # Download
+            40: 3,  # Plan (now prioritized over References, 40%)
+            85: 4,  # Implement (skip References, Repos and Index)
+            100: 4,  # Complete
+        }
+    else:
+        # Full workflow step mapping - new order: Initialize -> Analyze -> Download -> Plan -> References -> Repos -> Index -> Implement
+        step_mapping = {
+            5: 0,  # Initialize
+            10: 1,  # Analyze
+            25: 2,  # Download
+            40: 3,  # Plan (now 4th position, 40%)
+            50: 4,  # References (now 5th position, conditional, 50%)
+            60: 5,  # Repos (GitHub download)
+            70: 6,  # Index (code indexing)
+            85: 7,  # Implement (code implementation)
+            100: 7,  # Complete
+        }
+
+    current_step = 0
+
+    # Define enhanced progress callback function
+    def update_progress(progress: int, message: str):
+        nonlocal current_step
+
+        # Update progress bar
+        progress_bar.progress(progress)
+        status_text.markdown(f"**{message}**")
+
+        # Determine current step
+        new_step = step_mapping.get(progress, current_step)
+        if new_step != current_step:
+            current_step = new_step
+            update_step_indicator(
+                step_indicators, workflow_steps, current_step, "active"
+            )
+
+        time.sleep(0.3)  # Brief pause for users to see progress changes
+
+    # Step 1: Initialization
+    if chat_mode:
+        update_progress(5, "🚀 Initializing chat-based planning engine...")
+    elif enable_indexing:
+        update_progress(5, "🚀 Initializing AI research engine and loading models...")
+    else:
+        update_progress(
+            5, "🚀 Initializing AI research engine (Fast mode - indexing disabled)..."
+        )
+    update_step_indicator(step_indicators, workflow_steps, 0, "active")
+
+    # Start async processing with progress callback
+    with st.spinner("🔄 Processing workflow stages..."):
+        try:
+            # First try using simple async processing method
+            result = run_async_task_simple(
+                process_input_async(
+                    input_source, input_type, enable_indexing, update_progress
+                )
+            )
+        except Exception as e:
+            st.warning(f"Primary async method failed: {e}")
+            # Fallback method: use original thread pool method
+            try:
+                result = run_async_task(
+                    process_input_async(
+                        input_source, input_type, enable_indexing, update_progress
+                    )
+                )
+            except Exception as backup_error:
+                st.error(f"Both async methods failed. Error: {backup_error}")
+                return {
+                    "status": "error",
+                    "error": str(backup_error),
+                    "traceback": traceback.format_exc(),
+                }
+
+    # Update final status based on results
+    if result["status"] == "success":
+        # Complete all steps
+        update_progress(100, "✅ All processing stages completed successfully!")
+        update_step_indicator(
+            step_indicators, workflow_steps, len(workflow_steps), "completed"
+        )
+
+        # Display success information
+        st.balloons()  # Add celebration animation
+        if chat_mode:
+            display_status(
+                "🎉 Chat workflow completed! Your requirements have been analyzed and code has been generated.",
+                "success",
+            )
+        elif enable_indexing:
+            display_status(
+                "🎉 Workflow completed! Your research paper has been successfully processed and code has been generated.",
+                "success",
+            )
+        else:
+            display_status(
+                "🎉 Fast workflow completed! Your research paper has been processed (indexing skipped for faster processing).",
+                "success",
+            )
+
+    else:
+        # Processing failed
+        update_progress(0, "❌ Processing failed - see error details below")
+        update_step_indicator(step_indicators, workflow_steps, current_step, "error")
+        display_status(
+            f"❌ Processing encountered an error: {result.get('error', 'Unknown error')}",
+            "error",
+        )
+
+    # Wait a moment for users to see completion status
+    time.sleep(2.5)
+
+    return result
+
+
+def update_session_state_with_result(result: Dict[str, Any], input_type: str):
+    """
+    Update session state with result
+
+    Args:
+        result: Processing result
+        input_type: Input type
+    """
+    if result["status"] == "success":
+        # Save result to session state
+        st.session_state.last_result = result
+        st.session_state.show_results = True
+
+        # Save to history
+        st.session_state.results.append(
+            {
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "input_type": input_type,
+                "status": "success",
+                "result": result,
+            }
+        )
+    else:
+        # Save error information to session state for display
+        st.session_state.last_error = result.get("error", "Unknown error")
+
+        # Save error to history
+        st.session_state.results.append(
+            {
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "input_type": input_type,
+                "status": "error",
+                "error": result.get("error", "Unknown error"),
+            }
+        )
+
+    # Limit history to maximum 50 records
+    if len(st.session_state.results) > 50:
+        st.session_state.results = st.session_state.results[-50:]
+
+
+def cleanup_temp_file(input_source: str, input_type: str):
+    """
+    Cleanup temporary file
+
+    Args:
+        input_source: Input source
+        input_type: Input type
+    """
+    if input_type == "file" and input_source and os.path.exists(input_source):
+        try:
+            os.unlink(input_source)
+        except Exception:
+            pass
+
+
+def handle_start_processing_button(input_source: str, input_type: str):
+    """
+    Handle start processing button click
+
+    Args:
+        input_source: Input source
+        input_type: Input type
+    """
+    from .components import display_status
+
+    st.session_state.processing = True
+
+    # Get indexing toggle status
+    enable_indexing = st.session_state.get("enable_indexing", True)
+
+    try:
+        # Process workflow
+        result = handle_processing_workflow(input_source, input_type, enable_indexing)
+
+        # Display result status
+        if result["status"] == "success":
+            display_status("All operations completed successfully! 🎉", "success")
+        else:
+            display_status("Error during processing", "error")
+
+        # Update session state
+        update_session_state_with_result(result, input_type)
+
+    except Exception as e:
+        # Handle exceptional cases
+        st.error(f"Unexpected error during processing: {e}")
+        result = {"status": "error", "error": str(e)}
+        update_session_state_with_result(result, input_type)
+
+    finally:
+        # Reset state and clean up resources after processing
+        st.session_state.processing = False
+
+        # Clean up temporary files
+        cleanup_temp_file(input_source, input_type)
+
+        # Clean up system resources
+        cleanup_resources()
+
+        # Rerun to display results or errors
+        st.rerun()
+
+
+def handle_error_display():
+    """Handle error display"""
+    if hasattr(st.session_state, "last_error") and st.session_state.last_error:
+        st.error(f"❌ Error: {st.session_state.last_error}")
+        if st.button("🔄 Try Again", type="secondary", use_container_width=True):
+            st.session_state.last_error = None
+            st.session_state.task_counter += 1
+            st.rerun()
+
+
+def initialize_session_state():
+    """Initialize session state"""
+    if "processing" not in st.session_state:
+        st.session_state.processing = False
+    if "results" not in st.session_state:
+        st.session_state.results = []
+    if "current_step" not in st.session_state:
+        st.session_state.current_step = 0
+    if "task_counter" not in st.session_state:
+        st.session_state.task_counter = 0
+    if "show_results" not in st.session_state:
+        st.session_state.show_results = False
+    if "last_result" not in st.session_state:
+        st.session_state.last_result = None
+    if "last_error" not in st.session_state:
+        st.session_state.last_error = None
+    if "enable_indexing" not in st.session_state:
+        st.session_state.enable_indexing = (
+            False  # Default enable indexing functionality
+        )
+
+
+def cleanup_resources():
+    """
+    Clean up system resources to prevent memory leaks
+    """
+    try:
+        import gc
+        import threading
+        import multiprocessing
+        import asyncio
+        import sys
+
+        # 1. Clean up asyncio-related resources
+        try:
+            # Get current event loop (if exists)
+            try:
+                loop = asyncio.get_running_loop()
+                # Cancel all pending tasks
+                if loop and not loop.is_closed():
+                    pending_tasks = [
+                        task for task in asyncio.all_tasks(loop) if not task.done()
+                    ]
+                    if pending_tasks:
+                        for task in pending_tasks:
+                            if not task.cancelled():
+                                task.cancel()
+                        # Wait for task cancellation to complete
+                        try:
+                            if pending_tasks:
+                                # Use timeout to avoid blocking too long
+                                import time
+
+                                time.sleep(0.1)
+                        except Exception:
+                            pass
+            except RuntimeError:
+                # No running event loop, continue with other cleanup
+                pass
+        except Exception:
+            pass
+
+        # 2. Force garbage collection
+        gc.collect()
+
+        # 3. Clean up active threads (except main thread)
+        active_threads = threading.active_count()
+        if active_threads > 1:
+            # Wait some time for threads to naturally finish
+            import time
+
+            time.sleep(0.5)
+
+        # 4. Clean up multiprocessing resources
+        try:
+            # Clean up possible multiprocessing resources
+            if hasattr(multiprocessing, "active_children"):
+                for child in multiprocessing.active_children():
+                    if child.is_alive():
+                        child.terminate()
+                        child.join(timeout=1.0)
+                        # If join times out, force kill
+                        if child.is_alive():
+                            try:
+                                child.kill()
+                                child.join(timeout=0.5)
+                            except Exception:
+                                pass
+
+            # Clean up multiprocessing-related resource tracker
+            try:
+                import multiprocessing.resource_tracker
+
+                if hasattr(multiprocessing.resource_tracker, "_resource_tracker"):
+                    tracker = multiprocessing.resource_tracker._resource_tracker
+                    if tracker and hasattr(tracker, "_stop"):
+                        tracker._stop()
+            except Exception:
+                pass
+
+        except Exception:
+            pass
+
+        # 5. Force clean up Python internal caches
+        try:
+            # Clean up some temporary objects in module cache
+            import sys
+
+            # Don't delete key modules, only clean up possible temporary resources
+            if hasattr(sys, "_clear_type_cache"):
+                sys._clear_type_cache()
+        except Exception:
+            pass
+
+        # 6. Final garbage collection
+        gc.collect()
+
+    except Exception as e:
+        # Silently handle cleanup errors to avoid affecting main flow
+        # But can log errors in debug mode
+        try:
+            import logging
+
+            logging.getLogger(__name__).debug(f"Resource cleanup warning: {e}")
+        except Exception:
+            pass

projects/ui/DeepCode/ui/layout.py

@@ -0,0 +1,106 @@
+"""
+Streamlit Page Layout Module
+
+Contains main page layout and flow control
+"""
+
+import streamlit as st
+
+from .components import (
+    display_header,
+    display_features,
+    sidebar_control_panel,
+    input_method_selector,
+    results_display_component,
+    footer_component,
+)
+from .handlers import (
+    initialize_session_state,
+    handle_start_processing_button,
+    handle_error_display,
+)
+from .styles import get_main_styles
+
+
+def setup_page_config():
+    """Setup page configuration"""
+    st.set_page_config(
+        page_title="DeepCode - AI Research Engine",
+        page_icon="🧬",
+        layout="wide",
+        initial_sidebar_state="expanded",
+    )
+
+
+def apply_custom_styles():
+    """Apply custom styles"""
+    st.markdown(get_main_styles(), unsafe_allow_html=True)
+
+
+def render_main_content():
+    """Render main content area"""
+    # Display header and features
+    display_header()
+    display_features()
+    st.markdown("---")
+
+    # Display results if available
+    if st.session_state.show_results and st.session_state.last_result:
+        results_display_component(
+            st.session_state.last_result, st.session_state.task_counter
+        )
+        st.markdown("---")
+        return
+
+    # Show input interface only when not displaying results
+    if not st.session_state.show_results:
+        render_input_interface()
+
+    # Display error messages if any
+    handle_error_display()
+
+
+def render_input_interface():
+    """Render input interface"""
+    # Get input source and type
+    input_source, input_type = input_method_selector(st.session_state.task_counter)
+
+    # Processing button
+    if input_source and not st.session_state.processing:
+        if st.button("🚀 Start Processing", type="primary", use_container_width=True):
+            handle_start_processing_button(input_source, input_type)
+
+    elif st.session_state.processing:
+        st.info("🔄 Processing in progress... Please wait.")
+        st.warning("⚠️ Do not refresh the page or close the browser during processing.")
+
+    elif not input_source:
+        st.info("👆 Please upload a file or enter a URL to start processing.")
+
+
+def render_sidebar():
+    """Render sidebar"""
+    return sidebar_control_panel()
+
+
+def main_layout():
+    """Main layout function"""
+    # Initialize session state
+    initialize_session_state()
+
+    # Setup page configuration
+    setup_page_config()
+
+    # Apply custom styles
+    apply_custom_styles()
+
+    # Render sidebar
+    sidebar_info = render_sidebar()
+
+    # Render main content
+    render_main_content()
+
+    # Display footer
+    footer_component()
+
+    return sidebar_info

projects/ui/DeepCode/ui/streamlit_app.py

@@ -0,0 +1,38 @@
+"""
+DeepCode - AI Research Engine
+
+Streamlit Web Interface Main Application File
+"""
+
+import os
+import sys
+
+# Disable .pyc file generation
+os.environ["PYTHONDONTWRITEBYTECODE"] = "1"
+
+# Add parent directory to path for module imports
+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)
+
+# Import UI modules
+from ui.layout import main_layout
+
+
+def main():
+    """
+    Main function - Streamlit application entry
+
+    All UI logic has been modularized into ui/ folder
+    """
+    # Run main layout
+    sidebar_info = main_layout()
+
+    # Additional global logic can be added here if needed
+
+    return sidebar_info
+
+
+if __name__ == "__main__":
+    main()

projects/ui/DeepCode/ui/styles.py

@@ -0,0 +1,2590 @@
+"""
+Streamlit UI Styles Module
+
+Contains all CSS style definitions for the application
+"""
+
+
+def get_main_styles() -> str:
+    """
+    Get main CSS styles
+
+    Returns:
+        CSS styles string
+    """
+    return """
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;700&family=Inter:wght@300;400;600;700&display=swap');
+
+        :root {
+            --primary-bg: #0a0e27;
+            --secondary-bg: #1a1f3a;
+            --accent-bg: #2d3748;
+            --card-bg: rgba(45, 55, 72, 0.9);
+            --glass-bg: rgba(255, 255, 255, 0.08);
+            --glass-border: rgba(255, 255, 255, 0.12);
+            --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            --accent-gradient: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+            --neon-blue: #64b5f6;
+            --neon-cyan: #4dd0e1;
+            --neon-green: #81c784;
+            --neon-purple: #ba68c8;
+            --text-primary: #ffffff;
+            --text-secondary: #e3f2fd;
+            --text-muted: #90caf9;
+            --border-color: rgba(100, 181, 246, 0.2);
+        }
+
+        /* Light theme variables - Using dark theme colors */
+        :root {
+            --light-primary-bg: #0a0e27;
+            --light-secondary-bg: #1a1f3a;
+            --light-accent-bg: #2d3748;
+            --light-card-bg: rgba(45, 55, 72, 0.9);
+            --light-border-soft: rgba(100, 181, 246, 0.2);
+            --light-border-medium: rgba(100, 181, 246, 0.4);
+            --light-text-primary: #ffffff;
+            --light-text-secondary: #e3f2fd;
+            --light-text-muted: #90caf9;
+            --light-accent-blue: #64b5f6;
+            --light-accent-cyan: #4dd0e1;
+            --light-accent-green: #81c784;
+            --light-accent-purple: #ba68c8;
+        }
+
+        /* Global app background and text */
+        .stApp {
+            background: linear-gradient(135deg, var(--primary-bg) 0%, var(--secondary-bg) 100%);
+            color: var(--text-primary);
+            font-family: 'Inter', sans-serif;
+        }
+
+        /* Force high contrast for all text elements */
+        .stApp * {
+            color: var(--text-primary) !important;
+        }
+
+        /* Sidebar redesign - dark tech theme */
+        .css-1d391kg {
+            background: linear-gradient(180deg, #0d1117 0%, #161b22 50%, #21262d 100%) !important;
+            border-right: 2px solid var(--neon-cyan) !important;
+            box-shadow: 0 0 20px rgba(77, 208, 225, 0.3) !important;
+        }
+
+        /* Light mode sidebar - soft and gentle */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg {
+                background: linear-gradient(180deg, var(--light-primary-bg) 0%, var(--light-secondary-bg) 50%, var(--light-accent-bg) 100%) !important;
+                border-right: 1px solid var(--light-border-soft) !important;
+                box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05) !important;
+            }
+        }
+
+        /* Alternative light theme detection for Streamlit light theme */
+        [data-theme="light"] .css-1d391kg,
+        .css-1d391kg[data-theme="light"] {
+            background: linear-gradient(180deg, var(--light-primary-bg) 0%, var(--light-secondary-bg) 50%, var(--light-accent-bg) 100%) !important;
+            border-right: 1px solid var(--light-border-soft) !important;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05) !important;
+        }
+
+        .css-1d391kg * {
+            color: var(--text-primary) !important;
+            font-weight: 500 !important;
+        }
+
+        .css-1d391kg h3 {
+            color: var(--neon-cyan) !important;
+            font-weight: 700 !important;
+            font-size: 1.2rem !important;
+            text-shadow: 0 0 15px rgba(77, 208, 225, 0.6) !important;
+            border-bottom: 1px solid rgba(77, 208, 225, 0.3) !important;
+            padding-bottom: 0.5rem !important;
+            margin-bottom: 1rem !important;
+        }
+
+        /* Light mode text styling */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg * {
+                color: var(--light-text-primary) !important;
+                font-weight: 500 !important;
+            }
+
+            .css-1d391kg h3 {
+                color: var(--light-accent-blue) !important;
+                font-weight: 600 !important;
+                font-size: 1.2rem !important;
+                text-shadow: none !important;
+                border-bottom: 1px solid var(--light-border-soft) !important;
+                padding-bottom: 0.5rem !important;
+                margin-bottom: 1rem !important;
+            }
+        }
+
+        /* Alternative light theme detection */
+        [data-theme="light"] .css-1d391kg *,
+        .css-1d391kg[data-theme="light"] * {
+            color: var(--light-text-primary) !important;
+            font-weight: 500 !important;
+        }
+
+        [data-theme="light"] .css-1d391kg h3,
+        .css-1d391kg[data-theme="light"] h3 {
+            color: var(--light-accent-blue) !important;
+            font-weight: 600 !important;
+            font-size: 1.2rem !important;
+            text-shadow: none !important;
+            border-bottom: 1px solid var(--light-border-soft) !important;
+            padding-bottom: 0.5rem !important;
+            margin-bottom: 1rem !important;
+        }
+
+        .css-1d391kg p, .css-1d391kg div {
+            color: var(--text-primary) !important;
+            font-weight: 600 !important;
+        }
+
+        /* Sidebar info boxes - dark tech style */
+        .css-1d391kg .stAlert,
+        .css-1d391kg .stInfo,
+        .css-1d391kg .stSuccess,
+        .css-1d391kg .stWarning,
+        .css-1d391kg .stError {
+            background: linear-gradient(135deg, #0d1117 0%, #161b22 100%) !important;
+            border: 2px solid var(--neon-cyan) !important;
+            color: var(--text-primary) !important;
+            font-weight: 700 !important;
+            border-radius: 12px !important;
+            box-shadow: 0 0 15px rgba(77, 208, 225, 0.3) !important;
+            backdrop-filter: blur(10px) !important;
+            margin: 0.5rem 0 !important;
+            padding: 1rem !important;
+        }
+
+        /* Light mode info boxes - soft and gentle */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg .stAlert,
+            .css-1d391kg .stInfo,
+            .css-1d391kg .stSuccess,
+            .css-1d391kg .stWarning,
+            .css-1d391kg .stError {
+                background: var(--light-card-bg) !important;
+                border: 1px solid var(--light-border-soft) !important;
+                color: var(--light-text-primary) !important;
+                font-weight: 500 !important;
+                border-radius: 8px !important;
+                box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1) !important;
+                backdrop-filter: none !important;
+                margin: 0.5rem 0 !important;
+                padding: 0.8rem !important;
+            }
+
+            .css-1d391kg .stInfo {
+                border-left: 3px solid var(--light-accent-blue) !important;
+            }
+
+            .css-1d391kg .stSuccess {
+                border-left: 3px solid var(--light-accent-green) !important;
+            }
+
+            .css-1d391kg .stWarning {
+                border-left: 3px solid #f59e0b !important;
+            }
+
+            .css-1d391kg .stError {
+                border-left: 3px solid #ef4444 !important;
+            }
+        }
+
+        /* Alternative light theme detection for info boxes */
+        [data-theme="light"] .css-1d391kg .stAlert,
+        [data-theme="light"] .css-1d391kg .stInfo,
+        [data-theme="light"] .css-1d391kg .stSuccess,
+        [data-theme="light"] .css-1d391kg .stWarning,
+        [data-theme="light"] .css-1d391kg .stError,
+        .css-1d391kg[data-theme="light"] .stAlert,
+        .css-1d391kg[data-theme="light"] .stInfo,
+        .css-1d391kg[data-theme="light"] .stSuccess,
+        .css-1d391kg[data-theme="light"] .stWarning,
+        .css-1d391kg[data-theme="light"] .stError {
+            background: var(--light-card-bg) !important;
+            border: 1px solid var(--light-border-soft) !important;
+            color: var(--light-text-primary) !important;
+            font-weight: 500 !important;
+            border-radius: 8px !important;
+            box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1) !important;
+            backdrop-filter: none !important;
+            margin: 0.5rem 0 !important;
+            padding: 0.8rem !important;
+        }
+
+        /* Force white text for sidebar info boxes */
+        .css-1d391kg .stInfo div,
+        .css-1d391kg .stInfo p,
+        .css-1d391kg .stInfo span {
+            color: #ffffff !important;
+            font-weight: 700 !important;
+            font-size: 0.9rem !important;
+        }
+
+        /* Light mode: Override white text for sidebar info boxes */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg .stInfo div,
+            .css-1d391kg .stInfo p,
+            .css-1d391kg .stInfo span {
+                color: var(--light-text-primary) !important;
+                font-weight: 600 !important;
+                font-size: 0.9rem !important;
+            }
+        }
+
+        /* Alternative light theme detection for info box text */
+        [data-theme="light"] .css-1d391kg .stInfo div,
+        [data-theme="light"] .css-1d391kg .stInfo p,
+        [data-theme="light"] .css-1d391kg .stInfo span,
+        .css-1d391kg[data-theme="light"] .stInfo div,
+        .css-1d391kg[data-theme="light"] .stInfo p,
+        .css-1d391kg[data-theme="light"] .stInfo span {
+            color: var(--light-text-primary) !important;
+            font-weight: 600 !important;
+            font-size: 0.9rem !important;
+        }
+
+        /* Light mode: Override all alert/info box text colors */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg .stAlert div,
+            .css-1d391kg .stAlert p,
+            .css-1d391kg .stAlert span,
+            .css-1d391kg .stSuccess div,
+            .css-1d391kg .stSuccess p,
+            .css-1d391kg .stSuccess span,
+            .css-1d391kg .stWarning div,
+            .css-1d391kg .stWarning p,
+            .css-1d391kg .stWarning span,
+            .css-1d391kg .stError div,
+            .css-1d391kg .stError p,
+            .css-1d391kg .stError span {
+                color: var(--light-text-primary) !important;
+                font-weight: 600 !important;
+                font-size: 0.9rem !important;
+            }
+        }
+
+        /* Alternative light theme detection for all alert boxes */
+        [data-theme="light"] .css-1d391kg .stAlert div,
+        [data-theme="light"] .css-1d391kg .stAlert p,
+        [data-theme="light"] .css-1d391kg .stAlert span,
+        [data-theme="light"] .css-1d391kg .stSuccess div,
+        [data-theme="light"] .css-1d391kg .stSuccess p,
+        [data-theme="light"] .css-1d391kg .stSuccess span,
+        [data-theme="light"] .css-1d391kg .stWarning div,
+        [data-theme="light"] .css-1d391kg .stWarning p,
+        [data-theme="light"] .css-1d391kg .stWarning span,
+        [data-theme="light"] .css-1d391kg .stError div,
+        [data-theme="light"] .css-1d391kg .stError p,
+        [data-theme="light"] .css-1d391kg .stError span,
+        .css-1d391kg[data-theme="light"] .stAlert div,
+        .css-1d391kg[data-theme="light"] .stAlert p,
+        .css-1d391kg[data-theme="light"] .stAlert span,
+        .css-1d391kg[data-theme="light"] .stSuccess div,
+        .css-1d391kg[data-theme="light"] .stSuccess p,
+        .css-1d391kg[data-theme="light"] .stSuccess span,
+        .css-1d391kg[data-theme="light"] .stWarning div,
+        .css-1d391kg[data-theme="light"] .stWarning p,
+        .css-1d391kg[data-theme="light"] .stWarning span,
+        .css-1d391kg[data-theme="light"] .stError div,
+        .css-1d391kg[data-theme="light"] .stError p,
+        .css-1d391kg[data-theme="light"] .stError span {
+            color: var(--light-text-primary) !important;
+            font-weight: 600 !important;
+            font-size: 0.9rem !important;
+        }
+
+        /* ============================================
+           LIGHT MODE: COMPREHENSIVE TEXT OVERRIDE
+           ============================================ */
+
+        /* Light mode: Comprehensive sidebar text color override */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg,
+            .css-1d391kg * {
+                color: var(--light-text-primary) !important;
+            }
+
+            .css-1d391kg h1,
+            .css-1d391kg h2,
+            .css-1d391kg h3,
+            .css-1d391kg h4,
+            .css-1d391kg h5,
+            .css-1d391kg h6 {
+                color: var(--light-accent-blue) !important;
+            }
+        }
+
+        /* Alternative light theme detection - Comprehensive override */
+        [data-theme="light"] .css-1d391kg,
+        [data-theme="light"] .css-1d391kg *,
+        .css-1d391kg[data-theme="light"],
+        .css-1d391kg[data-theme="light"] * {
+            color: var(--light-text-primary) !important;
+        }
+
+        [data-theme="light"] .css-1d391kg h1,
+        [data-theme="light"] .css-1d391kg h2,
+        [data-theme="light"] .css-1d391kg h3,
+        [data-theme="light"] .css-1d391kg h4,
+        [data-theme="light"] .css-1d391kg h5,
+        [data-theme="light"] .css-1d391kg h6,
+        .css-1d391kg[data-theme="light"] h1,
+        .css-1d391kg[data-theme="light"] h2,
+        .css-1d391kg[data-theme="light"] h3,
+        .css-1d391kg[data-theme="light"] h4,
+        .css-1d391kg[data-theme="light"] h5,
+        .css-1d391kg[data-theme="light"] h6 {
+            color: var(--light-accent-blue) !important;
+        }
+
+        /* ================================
+           AI ANIMATION EFFECTS & LOGOS
+           ================================ */
+
+        /* AI Brain Logo Animation */
+        .ai-brain-logo {
+            position: absolute;
+            width: 80px;
+            height: 80px;
+            z-index: 1;
+        }
+
+        .brain-node {
+            position: absolute;
+            width: 12px;
+            height: 12px;
+            background: var(--neon-cyan);
+            border-radius: 50%;
+            box-shadow: 0 0 15px var(--neon-cyan);
+            animation: brainPulse 2s ease-in-out infinite;
+        }
+
+        .brain-node.node-1 {
+            top: 10px;
+            left: 20px;
+            animation-delay: 0s;
+        }
+
+        .brain-node.node-2 {
+            top: 30px;
+            right: 15px;
+            animation-delay: 0.7s;
+        }
+
+        .brain-node.node-3 {
+            bottom: 15px;
+            left: 30px;
+            animation-delay: 1.4s;
+        }
+
+        .brain-connection {
+            position: absolute;
+            background: linear-gradient(45deg, transparent, var(--neon-cyan), transparent);
+            height: 2px;
+            border-radius: 1px;
+            animation: connectionFlow 3s ease-in-out infinite;
+        }
+
+        .brain-connection.conn-1 {
+            width: 30px;
+            top: 20px;
+            left: 25px;
+            transform: rotate(45deg);
+        }
+
+        .brain-connection.conn-2 {
+            width: 25px;
+            top: 40px;
+            left: 15px;
+            transform: rotate(-30deg);
+            animation-delay: 1s;
+        }
+
+        @keyframes brainPulse {
+            0%, 100% {
+                transform: scale(1);
+                opacity: 0.7;
+                box-shadow: 0 0 15px var(--neon-cyan);
+            }
+            50% {
+                transform: scale(1.3);
+                opacity: 1;
+                box-shadow: 0 0 25px var(--neon-cyan), 0 0 35px var(--neon-cyan);
+            }
+        }
+
+        @keyframes connectionFlow {
+            0% {
+                opacity: 0;
+                background: linear-gradient(45deg, transparent, transparent, transparent);
+            }
+            50% {
+                opacity: 1;
+                background: linear-gradient(45deg, transparent, var(--neon-cyan), transparent);
+            }
+            100% {
+                opacity: 0;
+                background: linear-gradient(45deg, transparent, transparent, transparent);
+            }
+        }
+
+        /* Multi-Agent Logo Animation */
+        .multi-agent-logo {
+            position: absolute;
+            width: 80px;
+            height: 80px;
+            z-index: 1;
+        }
+
+        .agent-node {
+            position: absolute;
+            width: 20px;
+            height: 20px;
+            background: rgba(186, 104, 200, 0.2);
+            border: 2px solid var(--neon-purple);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 10px;
+            animation: agentOrbit 4s linear infinite;
+        }
+
+        .agent-node.agent-1 {
+            top: 5px;
+            left: 30px;
+            animation-delay: 0s;
+        }
+
+        .agent-node.agent-2 {
+            top: 30px;
+            right: 5px;
+            animation-delay: 1.3s;
+        }
+
+        .agent-node.agent-3 {
+            bottom: 5px;
+            left: 15px;
+            animation-delay: 2.6s;
+        }
+
+        .agent-connection {
+            position: absolute;
+            background: linear-gradient(90deg, transparent, var(--neon-purple), transparent);
+            height: 1px;
+            animation: agentSync 3s ease-in-out infinite;
+        }
+
+        .agent-connection.conn-12 {
+            width: 25px;
+            top: 20px;
+            left: 40px;
+            transform: rotate(30deg);
+        }
+
+        .agent-connection.conn-23 {
+            width: 30px;
+            top: 45px;
+            left: 25px;
+            transform: rotate(-45deg);
+            animation-delay: 1s;
+        }
+
+        .agent-connection.conn-13 {
+            width: 20px;
+            top: 25px;
+            left: 25px;
+            transform: rotate(90deg);
+            animation-delay: 2s;
+        }
+
+        @keyframes agentOrbit {
+            0% { transform: rotate(0deg) translateX(15px) rotate(0deg); }
+            100% { transform: rotate(360deg) translateX(15px) rotate(-360deg); }
+        }
+
+        @keyframes agentSync {
+            0%, 100% { opacity: 0.3; }
+            50% { opacity: 1; }
+        }
+
+        /* Future Vision Orbit Logo */
+        .future-logo {
+            position: absolute;
+            width: 80px;
+            height: 80px;
+            z-index: 1;
+        }
+
+        .orbit {
+            position: absolute;
+            border: 1px solid rgba(129, 199, 132, 0.3);
+            border-radius: 50%;
+            animation: orbitRotation 8s linear infinite;
+        }
+
+        .orbit-1 {
+            width: 60px;
+            height: 60px;
+            top: 10px;
+            left: 10px;
+        }
+
+        .orbit-2 {
+            width: 40px;
+            height: 40px;
+            top: 20px;
+            left: 20px;
+            animation-direction: reverse;
+            animation-duration: 6s;
+        }
+
+        .orbit-node {
+            position: absolute;
+            top: -8px;
+            left: 50%;
+            transform: translateX(-50%);
+            width: 16px;
+            height: 16px;
+            background: var(--neon-green);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 8px;
+            box-shadow: 0 0 10px var(--neon-green);
+        }
+
+        .orbit-center {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            width: 20px;
+            height: 20px;
+            background: radial-gradient(circle, var(--neon-green), var(--neon-cyan));
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 10px;
+            animation: centerPulse 2s ease-in-out infinite;
+        }
+
+        @keyframes orbitRotation {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        @keyframes centerPulse {
+            0%, 100% {
+                transform: translate(-50%, -50%) scale(1);
+                box-shadow: 0 0 15px var(--neon-green);
+            }
+            50% {
+                transform: translate(-50%, -50%) scale(1.2);
+                box-shadow: 0 0 25px var(--neon-green), 0 0 35px var(--neon-cyan);
+            }
+        }
+
+        /* Open Source Logo Animation */
+        .opensource-logo {
+            position: absolute;
+            width: 80px;
+            height: 80px;
+            z-index: 1;
+        }
+
+        .github-stars {
+            position: absolute;
+            width: 100%;
+            height: 100%;
+        }
+
+        .star {
+            position: absolute;
+            font-size: 14px;
+            animation: starTwinkle 3s ease-in-out infinite;
+        }
+
+        .star-1 {
+            top: 10px;
+            left: 15px;
+            animation-delay: 0s;
+        }
+
+        .star-2 {
+            top: 15px;
+            right: 10px;
+            animation-delay: 1s;
+        }
+
+        .star-3 {
+            bottom: 10px;
+            left: 25px;
+            animation-delay: 2s;
+        }
+
+        .community-nodes {
+            position: absolute;
+            width: 100%;
+            height: 100%;
+        }
+
+        .community-node {
+            position: absolute;
+            width: 18px;
+            height: 18px;
+            background: rgba(100, 181, 246, 0.2);
+            border: 1px solid var(--neon-blue);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 10px;
+            animation: communityFloat 4s ease-in-out infinite;
+        }
+
+        .community-node:nth-child(1) {
+            top: 35px;
+            left: 5px;
+            animation-delay: 0s;
+        }
+
+        .community-node:nth-child(2) {
+            top: 25px;
+            right: 8px;
+            animation-delay: 1.3s;
+        }
+
+        .community-node:nth-child(3) {
+            bottom: 20px;
+            left: 30px;
+            animation-delay: 2.6s;
+        }
+
+        @keyframes starTwinkle {
+            0%, 100% {
+                opacity: 0.5;
+                transform: scale(1);
+            }
+            50% {
+                opacity: 1;
+                transform: scale(1.3);
+            }
+        }
+
+        @keyframes communityFloat {
+            0%, 100% {
+                transform: translateY(0);
+                opacity: 0.7;
+            }
+            50% {
+                transform: translateY(-5px);
+                opacity: 1;
+            }
+        }
+
+        /* Typing number animation */
+        .typing-number {
+            animation: numberCount 2s ease-out;
+        }
+
+        @keyframes numberCount {
+            0% {
+                opacity: 0;
+                transform: scale(0.5);
+            }
+            100% {
+                opacity: 1;
+                transform: scale(1);
+            }
+        }
+
+        /* Sidebar buttons - tech style */
+        .css-1d391kg .stButton button {
+            background: linear-gradient(135deg, var(--neon-cyan) 0%, var(--neon-blue) 100%) !important;
+            color: #000000 !important;
+            font-weight: 800 !important;
+            border: 2px solid var(--neon-cyan) !important;
+            border-radius: 10px !important;
+            box-shadow: 0 0 20px rgba(77, 208, 225, 0.4) !important;
+            text-shadow: none !important;
+            transition: all 0.3s ease !important;
+        }
+
+        .css-1d391kg .stButton button:hover {
+            box-shadow: 0 0 30px rgba(77, 208, 225, 0.6) !important;
+            transform: translateY(-2px) !important;
+        }
+
+        /* Light mode sidebar buttons - gentle and modern */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg .stButton button {
+                background: linear-gradient(135deg, var(--light-accent-blue) 0%, var(--light-accent-cyan) 100%) !important;
+                color: #ffffff !important;
+                font-weight: 600 !important;
+                border: 1px solid var(--light-accent-blue) !important;
+                border-radius: 6px !important;
+                box-shadow: 0 2px 4px rgba(59, 130, 246, 0.15) !important;
+                text-shadow: none !important;
+                transition: all 0.2s ease !important;
+            }
+
+            .css-1d391kg .stButton button:hover {
+                box-shadow: 0 4px 8px rgba(59, 130, 246, 0.25) !important;
+                transform: translateY(-1px) !important;
+            }
+        }
+
+        /* Alternative light theme detection for buttons */
+        [data-theme="light"] .css-1d391kg .stButton button,
+        .css-1d391kg[data-theme="light"] .stButton button {
+            background: linear-gradient(135deg, var(--light-accent-blue) 0%, var(--light-accent-cyan) 100%) !important;
+            color: #ffffff !important;
+            font-weight: 600 !important;
+            border: 1px solid var(--light-accent-blue) !important;
+            border-radius: 6px !important;
+            box-shadow: 0 2px 4px rgba(59, 130, 246, 0.15) !important;
+            text-shadow: none !important;
+            transition: all 0.2s ease !important;
+        }
+
+        [data-theme="light"] .css-1d391kg .stButton button:hover,
+        .css-1d391kg[data-theme="light"] .stButton button:hover {
+            box-shadow: 0 4px 8px rgba(59, 130, 246, 0.25) !important;
+            transform: translateY(-1px) !important;
+        }
+
+        /* Sidebar expanders - dark tech theme */
+        .css-1d391kg .streamlit-expanderHeader {
+            background: linear-gradient(135deg, #0d1117 0%, #161b22 100%) !important;
+            color: var(--text-primary) !important;
+            border: 2px solid var(--neon-purple) !important;
+            font-weight: 700 !important;
+            border-radius: 10px !important;
+            box-shadow: 0 0 10px rgba(186, 104, 200, 0.3) !important;
+        }
+
+        .css-1d391kg .streamlit-expanderContent {
+            background: linear-gradient(135deg, #0d1117 0%, #161b22 100%) !important;
+            border: 2px solid var(--neon-purple) !important;
+            color: var(--text-primary) !important;
+            border-radius: 0 0 10px 10px !important;
+            box-shadow: 0 0 10px rgba(186, 104, 200, 0.2) !important;
+        }
+
+        /* Light mode sidebar expanders - clean and minimal */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg .streamlit-expanderHeader {
+                background: var(--light-card-bg) !important;
+                color: var(--light-text-primary) !important;
+                border: 1px solid var(--light-border-medium) !important;
+                font-weight: 600 !important;
+                border-radius: 6px !important;
+                box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08) !important;
+            }
+
+            .css-1d391kg .streamlit-expanderContent {
+                background: var(--light-card-bg) !important;
+                border: 1px solid var(--light-border-medium) !important;
+                color: var(--light-text-primary) !important;
+                border-radius: 0 0 6px 6px !important;
+                box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05) !important;
+                border-top: none !important;
+            }
+        }
+
+        /* Alternative light theme detection for expanders */
+        [data-theme="light"] .css-1d391kg .streamlit-expanderHeader,
+        .css-1d391kg[data-theme="light"] .streamlit-expanderHeader {
+            background: var(--light-card-bg) !important;
+            color: var(--light-text-primary) !important;
+            border: 1px solid var(--light-border-medium) !important;
+            font-weight: 600 !important;
+            border-radius: 6px !important;
+            box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08) !important;
+        }
+
+        [data-theme="light"] .css-1d391kg .streamlit-expanderContent,
+        .css-1d391kg[data-theme="light"] .streamlit-expanderContent {
+            background: var(--light-card-bg) !important;
+            border: 1px solid var(--light-border-medium) !important;
+            color: var(--light-text-primary) !important;
+            border-radius: 0 0 6px 6px !important;
+            box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05) !important;
+            border-top: none !important;
+        }
+
+        /* Force high contrast for all sidebar text elements */
+        .css-1d391kg span,
+        .css-1d391kg p,
+        .css-1d391kg div,
+        .css-1d391kg label,
+        .css-1d391kg strong,
+        .css-1d391kg b {
+            color: #ffffff !important;
+            font-weight: 600 !important;
+        }
+
+        /* Light mode: Override all sidebar text colors */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg span,
+            .css-1d391kg p,
+            .css-1d391kg div,
+            .css-1d391kg label,
+            .css-1d391kg strong,
+            .css-1d391kg b {
+                color: var(--light-text-primary) !important;
+                font-weight: 600 !important;
+            }
+        }
+
+        /* Alternative light theme detection for all sidebar text */
+        [data-theme="light"] .css-1d391kg span,
+        [data-theme="light"] .css-1d391kg p,
+        [data-theme="light"] .css-1d391kg div,
+        [data-theme="light"] .css-1d391kg label,
+        [data-theme="light"] .css-1d391kg strong,
+        [data-theme="light"] .css-1d391kg b,
+        .css-1d391kg[data-theme="light"] span,
+        .css-1d391kg[data-theme="light"] p,
+        .css-1d391kg[data-theme="light"] div,
+        .css-1d391kg[data-theme="light"] label,
+        .css-1d391kg[data-theme="light"] strong,
+        .css-1d391kg[data-theme="light"] b {
+            color: var(--light-text-primary) !important;
+            font-weight: 600 !important;
+        }
+
+        /* Sidebar markdown content */
+        .css-1d391kg [data-testid="stMarkdownContainer"] p {
+            color: #ffffff !important;
+            font-weight: 600 !important;
+            background: none !important;
+        }
+
+        /* Light mode: Override sidebar markdown text */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg [data-testid="stMarkdownContainer"] p {
+                color: var(--light-text-primary) !important;
+                font-weight: 600 !important;
+                background: none !important;
+            }
+        }
+
+        /* Alternative light theme detection for markdown content */
+        [data-theme="light"] .css-1d391kg [data-testid="stMarkdownContainer"] p,
+        .css-1d391kg[data-theme="light"] [data-testid="stMarkdownContainer"] p {
+            color: var(--light-text-primary) !important;
+            font-weight: 600 !important;
+            background: none !important;
+        }
+
+        /* Sidebar special styles - system info boxes */
+        .css-1d391kg .element-container {
+            background: none !important;
+        }
+
+        .css-1d391kg .element-container div {
+            background: linear-gradient(135deg, #0d1117 0%, #161b22 100%) !important;
+            border: 1px solid var(--neon-cyan) !important;
+            border-radius: 8px !important;
+            padding: 0.8rem !important;
+            box-shadow: 0 0 10px rgba(77, 208, 225, 0.2) !important;
+            margin: 0.3rem 0 !important;
+        }
+
+        /* Processing History special handling */
+        .css-1d391kg .stExpander {
+            background: linear-gradient(135deg, #0d1117 0%, #161b22 100%) !important;
+            border: 2px solid var(--neon-green) !important;
+            border-radius: 12px !important;
+            box-shadow: 0 0 15px rgba(129, 199, 132, 0.3) !important;
+            margin: 0.5rem 0 !important;
+        }
+
+        /* Ensure all text is visible on dark background */
+        .css-1d391kg .stExpander div,
+        .css-1d391kg .stExpander p,
+        .css-1d391kg .stExpander span {
+            color: #ffffff !important;
+            font-weight: 600 !important;
+            background: none !important;
+        }
+
+        /* Light mode: Override expander text colors */
+        @media (prefers-color-scheme: light) {
+            .css-1d391kg .stExpander div,
+            .css-1d391kg .stExpander p,
+            .css-1d391kg .stExpander span {
+                color: var(--light-text-primary) !important;
+                font-weight: 600 !important;
+                background: none !important;
+            }
+        }
+
+        /* Alternative light theme detection for expander text */
+        [data-theme="light"] .css-1d391kg .stExpander div,
+        [data-theme="light"] .css-1d391kg .stExpander p,
+        [data-theme="light"] .css-1d391kg .stExpander span,
+        .css-1d391kg[data-theme="light"] .stExpander div,
+        .css-1d391kg[data-theme="light"] .stExpander p,
+        .css-1d391kg[data-theme="light"] .stExpander span {
+            color: var(--light-text-primary) !important;
+            font-weight: 600 !important;
+            background: none !important;
+        }
+
+        /* Main header area - enhanced version */
+        .main-header {
+            position: relative;
+            background: linear-gradient(135deg,
+                rgba(100, 181, 246, 0.12) 0%,
+                rgba(77, 208, 225, 0.10) 30%,
+                rgba(186, 104, 200, 0.12) 70%,
+                rgba(129, 199, 132, 0.10) 100%);
+            backdrop-filter: blur(25px);
+            border: 1px solid transparent;
+            background-clip: padding-box;
+            padding: 4rem 2rem;
+            border-radius: 25px;
+            margin-bottom: 3rem;
+            text-align: center;
+            overflow: hidden;
+            box-shadow:
+                0 20px 60px rgba(0, 0, 0, 0.4),
+                0 8px 32px rgba(100, 181, 246, 0.2),
+                inset 0 1px 0 rgba(255, 255, 255, 0.1);
+        }
+
+        .main-header::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: linear-gradient(45deg,
+                var(--neon-cyan) 0%,
+                var(--neon-purple) 25%,
+                var(--neon-blue) 50%,
+                var(--neon-green) 75%,
+                var(--neon-cyan) 100%);
+            background-size: 400% 400%;
+            border-radius: 25px;
+            padding: 1px;
+            margin: -1px;
+            z-index: -1;
+            animation: borderGlow 6s ease-in-out infinite;
+        }
+
+        .main-header::after {
+            content: '';
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            width: 300%;
+            height: 300%;
+            background: radial-gradient(circle, transparent 30%, rgba(77, 208, 225, 0.03) 60%, transparent 70%);
+            transform: translate(-50%, -50%);
+            animation: headerPulse 8s ease-in-out infinite;
+            pointer-events: none;
+        }
+
+        @keyframes headerPulse {
+            0%, 100% {
+                opacity: 0.3;
+                transform: translate(-50%, -50%) scale(1);
+            }
+            50% {
+                opacity: 0.7;
+                transform: translate(-50%, -50%) scale(1.1);
+            }
+        }
+
+        .main-header h1 {
+            font-family: 'JetBrains Mono', monospace !important;
+            font-size: 3.8rem !important;
+            font-weight: 800 !important;
+            background: linear-gradient(135deg, var(--neon-blue) 0%, var(--neon-cyan) 40%, #90caf9 80%, var(--neon-blue) 100%) !important;
+            background-size: 200% 200% !important;
+            -webkit-background-clip: text !important;
+            -webkit-text-fill-color: transparent !important;
+            background-clip: text !important;
+            text-shadow: 0 0 25px rgba(100, 181, 246, 0.4) !important;
+            margin-bottom: 1.2rem !important;
+            animation: titleGlow 4s ease-in-out infinite alternate, gradientShift 3s ease-in-out infinite !important;
+            position: relative;
+            z-index: 2;
+        }
+
+        @keyframes titleGlow {
+            0% {
+                filter: drop-shadow(0 0 10px rgba(100, 181, 246, 0.3)) drop-shadow(0 0 15px rgba(100, 181, 246, 0.2));
+                text-shadow: 0 0 25px rgba(100, 181, 246, 0.4);
+            }
+            33% {
+                filter: drop-shadow(0 0 12px rgba(77, 208, 225, 0.4)) drop-shadow(0 0 18px rgba(77, 208, 225, 0.25));
+                text-shadow: 0 0 30px rgba(77, 208, 225, 0.5);
+            }
+            66% {
+                filter: drop-shadow(0 0 14px rgba(144, 202, 249, 0.35)) drop-shadow(0 0 20px rgba(144, 202, 249, 0.2));
+                text-shadow: 0 0 35px rgba(144, 202, 249, 0.45);
+            }
+            100% {
+                filter: drop-shadow(0 0 10px rgba(100, 181, 246, 0.3)) drop-shadow(0 0 15px rgba(100, 181, 246, 0.2));
+                text-shadow: 0 0 25px rgba(100, 181, 246, 0.4);
+            }
+        }
+
+        @keyframes gradientShift {
+            0%, 100% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+        }
+
+        .main-header h3 {
+            font-family: 'Inter', sans-serif !important;
+            font-size: 1.2rem !important;
+            font-weight: 400 !important;
+            color: var(--text-secondary) !important;
+            letter-spacing: 2px !important;
+            margin-bottom: 0.5rem !important;
+        }
+
+        .main-header p {
+            font-family: 'JetBrains Mono', monospace !important;
+            font-size: 0.9rem !important;
+            color: var(--neon-green) !important;
+            letter-spacing: 1px !important;
+            font-weight: 600 !important;
+        }
+
+        /* Streamlit component style overrides */
+        .stMarkdown h3 {
+            color: var(--neon-cyan) !important;
+            font-family: 'Inter', sans-serif !important;
+            font-weight: 700 !important;
+            font-size: 1.5rem !important;
+            text-shadow: 0 0 10px rgba(77, 208, 225, 0.3) !important;
+        }
+
+        /* Radio button styles */
+        .stRadio > div {
+            background: var(--card-bg) !important;
+            border: 1px solid var(--border-color) !important;
+            border-radius: 12px !important;
+            padding: 1rem !important;
+            backdrop-filter: blur(10px) !important;
+        }
+
+        .stRadio label {
+            color: var(--text-primary) !important;
+            font-weight: 600 !important;
+            font-size: 1rem !important;
+        }
+
+        .stRadio > div > div > div > label {
+            color: var(--text-secondary) !important;
+            font-weight: 500 !important;
+            font-size: 1rem !important;
+        }
+
+        /* File uploader */
+        .stFileUploader > div {
+            background: var(--card-bg) !important;
+            border: 2px dashed var(--border-color) !important;
+            border-radius: 15px !important;
+            transition: all 0.3s ease !important;
+            backdrop-filter: blur(10px) !important;
+        }
+
+        .stFileUploader > div:hover {
+            border-color: var(--neon-cyan) !important;
+            box-shadow: 0 0 20px rgba(77, 208, 225, 0.3) !important;
+        }
+
+        .stFileUploader label {
+            color: var(--text-primary) !important;
+            font-weight: 600 !important;
+        }
+
+        .stFileUploader span {
+            color: var(--text-secondary) !important;
+            font-weight: 500 !important;
+        }
+
+        /* Text input fields */
+        .stTextInput > div > div > input {
+            background: var(--card-bg) !important;
+            border: 1px solid var(--border-color) !important;
+            border-radius: 10px !important;
+            color: var(--text-primary) !important;
+            font-weight: 500 !important;
+            backdrop-filter: blur(10px) !important;
+        }
+
+        .stTextInput > div > div > input:focus {
+            border-color: var(--neon-cyan) !important;
+            box-shadow: 0 0 0 1px var(--neon-cyan) !important;
+        }
+
+        .stTextInput label {
+            color: var(--text-primary) !important;
+            font-weight: 600 !important;
+        }
+
+        /* Button styles */
+        .stButton > button {
+            width: 100% !important;
+            background: var(--primary-gradient) !important;
+            color: white !important;
+            border: none !important;
+            border-radius: 12px !important;
+            padding: 0.8rem 2rem !important;
+            font-family: 'Inter', sans-serif !important;
+            font-weight: 600 !important;
+            font-size: 1rem !important;
+            letter-spacing: 0.5px !important;
+            transition: all 0.3s ease !important;
+            box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3) !important;
+        }
+
+        .stButton > button:hover {
+            transform: translateY(-2px) !important;
+            box-shadow: 0 6px 20px rgba(102, 126, 234, 0.4) !important;
+        }
+
+        /* Status message styles */
+        .status-success, .stSuccess {
+            background: linear-gradient(135deg, rgba(129, 199, 132, 0.15) 0%, rgba(129, 199, 132, 0.05) 100%) !important;
+            color: var(--neon-green) !important;
+            padding: 1rem 1.5rem !important;
+            border-radius: 10px !important;
+            border: 1px solid rgba(129, 199, 132, 0.3) !important;
+            backdrop-filter: blur(10px) !important;
+            font-weight: 600 !important;
+        }
+
+        .status-error, .stError {
+            background: linear-gradient(135deg, rgba(244, 67, 54, 0.15) 0%, rgba(244, 67, 54, 0.05) 100%) !important;
+            color: #ff8a80 !important;
+            padding: 1rem 1.5rem !important;
+            border-radius: 10px !important;
+            border: 1px solid rgba(244, 67, 54, 0.3) !important;
+            backdrop-filter: blur(10px) !important;
+            font-weight: 600 !important;
+        }
+
+        .status-warning, .stWarning {
+            background: linear-gradient(135deg, rgba(255, 193, 7, 0.15) 0%, rgba(255, 193, 7, 0.05) 100%) !important;
+            color: #ffcc02 !important;
+            padding: 1rem 1.5rem !important;
+            border-radius: 10px !important;
+            border: 1px solid rgba(255, 193, 7, 0.3) !important;
+            backdrop-filter: blur(10px) !important;
+            font-weight: 600 !important;
+        }
+
+        .status-info, .stInfo {
+            background: linear-gradient(135deg, rgba(77, 208, 225, 0.15) 0%, rgba(77, 208, 225, 0.05) 100%) !important;
+            color: var(--neon-cyan) !important;
+            padding: 1rem 1.5rem !important;
+            border-radius: 10px !important;
+            border: 1px solid rgba(77, 208, 225, 0.3) !important;
+            backdrop-filter: blur(10px) !important;
+            font-weight: 600 !important;
+        }
+
+        /* Progress bar */
+        .progress-container {
+            margin: 1.5rem 0;
+            padding: 2rem;
+            background: var(--card-bg);
+            backdrop-filter: blur(15px);
+            border: 1px solid var(--border-color);
+            border-radius: 15px;
+            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+        }
+
+        .stProgress > div > div > div {
+            background: var(--accent-gradient) !important;
+            border-radius: 10px !important;
+        }
+
+        /* Text area */
+        .stTextArea > div > div > textarea {
+            background: var(--card-bg) !important;
+            border: 1px solid var(--border-color) !important;
+            border-radius: 10px !important;
+            color: var(--text-primary) !important;
+            font-family: 'JetBrains Mono', monospace !important;
+            backdrop-filter: blur(10px) !important;
+        }
+
+        /* Expander */
+        .streamlit-expanderHeader {
+            background: var(--card-bg) !important;
+            color: var(--text-primary) !important;
+            border: 1px solid var(--border-color) !important;
+            font-weight: 600 !important;
+        }
+
+        .streamlit-expanderContent {
+            background: var(--card-bg) !important;
+            border: 1px solid var(--border-color) !important;
+        }
+
+        /* Ensure all Markdown content is visible */
+        [data-testid="stMarkdownContainer"] p {
+            color: var(--text-secondary) !important;
+            font-weight: 500 !important;
+        }
+
+        /* Dividers */
+        hr {
+            border-color: var(--border-color) !important;
+            opacity: 0.5 !important;
+        }
+
+        /* Scrollbars */
+        ::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        ::-webkit-scrollbar-track {
+            background: var(--accent-bg);
+            border-radius: 10px;
+        }
+
+        ::-webkit-scrollbar-thumb {
+            background: var(--accent-gradient);
+            border-radius: 10px;
+        }
+
+        ::-webkit-scrollbar-thumb:hover {
+            background: var(--primary-gradient);
+        }
+
+        /* Placeholder text */
+        ::placeholder {
+            color: var(--text-muted) !important;
+            opacity: 0.7 !important;
+        }
+
+        /* ================================
+           AI AGENT CAPABILITIES DISPLAY
+           ================================ */
+
+        /* AI Capabilities section - simplified to avoid conflicts with main header */
+        .ai-capabilities-section {
+            position: relative;
+            background: linear-gradient(135deg,
+                rgba(77, 208, 225, 0.08) 0%,
+                rgba(186, 104, 200, 0.06) 50%,
+                rgba(129, 199, 132, 0.08) 100%);
+            backdrop-filter: blur(15px);
+            border: 1px solid rgba(77, 208, 225, 0.2);
+            padding: 2rem 1.5rem;
+            border-radius: 20px;
+            margin: 2rem 0;
+            text-align: center;
+            overflow: hidden;
+            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.2);
+        }
+
+        .ai-capabilities-section::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: linear-gradient(90deg,
+                transparent 0%,
+                rgba(77, 208, 225, 0.1) 50%,
+                transparent 100%);
+            animation: shimmer 3s ease-in-out infinite;
+        }
+
+        @keyframes shimmer {
+            0% { transform: translateX(-100%); }
+            100% { transform: translateX(100%); }
+        }
+
+        @keyframes borderGlow {
+            0%, 100% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+        }
+
+        /* Neural network animation */
+        .neural-network {
+            position: absolute;
+            top: 1rem;
+            right: 2rem;
+            display: flex;
+            gap: 0.5rem;
+        }
+
+        .neuron {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: var(--neon-cyan);
+            box-shadow: 0 0 10px var(--neon-cyan);
+            animation-duration: 2s;
+            animation-iteration-count: infinite;
+            animation-timing-function: ease-in-out;
+        }
+
+        .pulse-1 { animation-name: neuronPulse; animation-delay: 0s; }
+        .pulse-2 { animation-name: neuronPulse; animation-delay: 0.3s; }
+        .pulse-3 { animation-name: neuronPulse; animation-delay: 0.6s; }
+
+        @keyframes neuronPulse {
+            0%, 100% {
+                transform: scale(1);
+                opacity: 0.7;
+                box-shadow: 0 0 10px var(--neon-cyan);
+            }
+            50% {
+                transform: scale(1.3);
+                opacity: 1;
+                box-shadow: 0 0 20px var(--neon-cyan), 0 0 30px var(--neon-cyan);
+            }
+        }
+
+        .capabilities-title {
+            font-family: 'Inter', sans-serif !important;
+            font-size: 2rem !important;
+            font-weight: 700 !important;
+            background: linear-gradient(135deg, var(--neon-cyan), var(--neon-purple), var(--neon-green));
+            background-clip: text;
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            text-shadow: 0 0 20px rgba(77, 208, 225, 0.3);
+            margin-bottom: 0.5rem !important;
+            letter-spacing: -0.5px;
+        }
+
+        .capabilities-subtitle {
+            font-family: 'JetBrains Mono', monospace !important;
+            color: var(--neon-cyan) !important;
+            font-size: 0.9rem !important;
+            letter-spacing: 1.5px !important;
+            font-weight: 500 !important;
+            text-transform: uppercase;
+            opacity: 0.8;
+        }
+
+        /* Enhanced feature card system - ensure alignment */
+        .feature-card {
+            position: relative;
+            background: var(--card-bg);
+            backdrop-filter: blur(20px);
+            border: 1px solid var(--border-color);
+            padding: 2.5rem;
+            border-radius: 20px;
+            margin: 1.5rem 0;
+            transition: all 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+            box-shadow: 0 8px 40px rgba(0, 0, 0, 0.3);
+            overflow: hidden;
+            /* Ensure card alignment */
+            min-height: 420px;
+            display: flex;
+            flex-direction: column;
+            justify-content: space-between;
+        }
+
+        /* NEW VERTICAL LAYOUT FEATURE CARDS */
+        .feature-card-vertical {
+            position: relative;
+            background: linear-gradient(135deg, var(--card-bg) 0%, rgba(45, 55, 72, 0.8) 100%);
+            backdrop-filter: blur(25px);
+            border: 1px solid var(--border-color);
+            padding: 0;
+            border-radius: 24px;
+            margin: 2.5rem 0;
+            transition: all 0.5s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+            box-shadow: 0 12px 60px rgba(0, 0, 0, 0.4);
+            overflow: hidden;
+            min-height: 500px;
+        }
+
+        .feature-card-vertical:hover {
+            transform: translateY(-8px) scale(1.01);
+            box-shadow: 0 20px 80px rgba(0, 0, 0, 0.5);
+        }
+
+        /* Card glow effect for vertical cards */
+        .card-glow-vertical {
+            position: absolute;
+            top: -50%;
+            left: -50%;
+            width: 200%;
+            height: 200%;
+            background: radial-gradient(circle, transparent 30%, rgba(77, 208, 225, 0.03) 60%, transparent 80%);
+            opacity: 0;
+            transition: opacity 0.5s ease;
+            pointer-events: none;
+            animation: verticalGlowPulse 8s ease-in-out infinite;
+        }
+
+        .feature-card-vertical:hover .card-glow-vertical {
+            opacity: 1;
+        }
+
+        @keyframes verticalGlowPulse {
+            0%, 100% {
+                transform: rotate(0deg) scale(1);
+                opacity: 0.3;
+            }
+            50% {
+                transform: rotate(180deg) scale(1.1);
+                opacity: 0.7;
+            }
+        }
+
+        /* Feature header section */
+        .feature-header {
+            display: flex;
+            align-items: center;
+            padding: 2.5rem 3rem 1.5rem 3rem;
+            background: linear-gradient(135deg, rgba(77, 208, 225, 0.08) 0%, rgba(186, 104, 200, 0.06) 100%);
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+            gap: 2rem;
+        }
+
+        .feature-logo-container {
+            position: relative;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            width: 80px;
+            height: 80px;
+            flex-shrink: 0;
+        }
+
+        .feature-icon-large {
+            font-size: 3.5rem;
+            z-index: 2;
+            filter: drop-shadow(0 0 15px rgba(77, 208, 225, 0.5));
+        }
+
+        .feature-header-content {
+            flex: 1;
+        }
+
+        .feature-title-large {
+            font-family: 'Inter', sans-serif !important;
+            color: var(--text-primary) !important;
+            font-size: 2rem !important;
+            font-weight: 700 !important;
+            margin-bottom: 0.5rem !important;
+            text-shadow: 0 0 20px rgba(255, 255, 255, 0.3);
+            background: linear-gradient(135deg, var(--neon-cyan), var(--neon-blue));
+            background-clip: text;
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+
+        .feature-subtitle {
+            color: var(--text-secondary) !important;
+            font-size: 1rem !important;
+            font-weight: 500 !important;
+            opacity: 0.9;
+        }
+
+        .feature-stats {
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+            align-items: flex-end;
+        }
+
+        .stat-item {
+            text-align: center;
+            padding: 0.8rem 1.2rem;
+            background: rgba(77, 208, 225, 0.1);
+            border: 1px solid rgba(77, 208, 225, 0.3);
+            border-radius: 12px;
+            backdrop-filter: blur(10px);
+            min-width: 80px;
+        }
+
+        .stat-number {
+            display: block;
+            font-family: 'JetBrains Mono', monospace !important;
+            color: var(--neon-cyan) !important;
+            font-size: 1.5rem !important;
+            font-weight: 700 !important;
+            text-shadow: 0 0 10px rgba(77, 208, 225, 0.5);
+        }
+
+        .stat-label {
+            display: block;
+            color: var(--text-secondary) !important;
+            font-size: 0.75rem !important;
+            font-weight: 500 !important;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+            margin-top: 0.2rem;
+        }
+
+        /* Feature content section */
+        .feature-content {
+            display: flex;
+            padding: 2.5rem 3rem;
+            gap: 3rem;
+            align-items: flex-start;
+        }
+
+        .content-left {
+            flex: 1.2;
+        }
+
+        .content-right {
+            flex: 1;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        .feature-description-large {
+            color: var(--text-secondary) !important;
+            font-size: 1.1rem !important;
+            line-height: 1.7 !important;
+            font-weight: 500 !important;
+            margin-bottom: 2rem;
+        }
+
+        /* Card glow effect */
+        .card-glow {
+            position: absolute;
+            top: -50%;
+            left: -50%;
+            width: 200%;
+            height: 200%;
+            background: radial-gradient(circle, transparent 20%, rgba(77, 208, 225, 0.05) 50%, transparent 70%);
+            opacity: 0;
+            transition: opacity 0.4s ease;
+            pointer-events: none;
+        }
+
+        .feature-card:hover .card-glow {
+            opacity: 1;
+            animation: glowRotate 3s linear infinite;
+        }
+
+        @keyframes glowRotate {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        /* Different themed card styles */
+        .feature-card.primary {
+            border-color: var(--neon-cyan);
+            background: linear-gradient(135deg,
+                rgba(77, 208, 225, 0.1) 0%,
+                rgba(45, 55, 72, 0.95) 30%);
+        }
+
+        .feature-card.primary:hover {
+            transform: translateY(-8px) scale(1.02);
+            border-color: var(--neon-cyan);
+            box-shadow:
+                0 20px 60px rgba(77, 208, 225, 0.3),
+                0 0 50px rgba(77, 208, 225, 0.2);
+        }
+
+        .feature-card.secondary {
+            border-color: var(--neon-purple);
+            background: linear-gradient(135deg,
+                rgba(186, 104, 200, 0.1) 0%,
+                rgba(45, 55, 72, 0.95) 30%);
+        }
+
+        .feature-card.secondary:hover {
+            transform: translateY(-8px) scale(1.02);
+            border-color: var(--neon-purple);
+            box-shadow:
+                0 20px 60px rgba(186, 104, 200, 0.3),
+                0 0 50px rgba(186, 104, 200, 0.2);
+        }
+
+        .feature-card.accent {
+            border-color: var(--neon-green);
+            background: linear-gradient(135deg,
+                rgba(129, 199, 132, 0.1) 0%,
+                rgba(45, 55, 72, 0.95) 30%);
+        }
+
+        .feature-card.accent:hover {
+            transform: translateY(-8px) scale(1.02);
+            border-color: var(--neon-green);
+            box-shadow:
+                0 20px 60px rgba(129, 199, 132, 0.3),
+                0 0 50px rgba(129, 199, 132, 0.2);
+        }
+
+        .feature-card.tech {
+            border-color: var(--neon-blue);
+            background: linear-gradient(135deg,
+                rgba(100, 181, 246, 0.1) 0%,
+                rgba(45, 55, 72, 0.95) 30%);
+        }
+
+        .feature-card.tech:hover {
+            transform: translateY(-8px) scale(1.02);
+            border-color: var(--neon-blue);
+            box-shadow:
+                0 20px 60px rgba(100, 181, 246, 0.3),
+                0 0 50px rgba(100, 181, 246, 0.2);
+        }
+
+        /* Feature icons */
+        .feature-icon {
+            font-size: 3rem;
+            margin-bottom: 1rem;
+            text-align: center;
+            filter: drop-shadow(0 0 10px rgba(77, 208, 225, 0.5));
+            flex-shrink: 0;
+        }
+
+        /* Feature titles */
+        .feature-title {
+            font-family: 'Inter', sans-serif !important;
+            color: var(--text-primary) !important;
+            font-size: 1.3rem !important;
+            font-weight: 700 !important;
+            margin-bottom: 1rem !important;
+            text-align: center;
+            text-shadow: 0 0 15px rgba(255, 255, 255, 0.3);
+            flex-shrink: 0;
+        }
+
+        /* Feature descriptions */
+        .feature-description {
+            color: var(--text-secondary) !important;
+            line-height: 1.6 !important;
+            font-weight: 500 !important;
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            justify-content: space-between;
+        }
+
+        /* Typing animation effect */
+        .typing-text {
+            font-family: 'JetBrains Mono', monospace !important;
+            font-size: 0.95rem !important;
+            margin-bottom: 1.5rem;
+            border-right: 2px solid var(--neon-cyan);
+            white-space: nowrap;
+            overflow: hidden;
+            animation: typing 3s steps(60, end), blink 1s infinite;
+        }
+
+        @keyframes typing {
+            from { width: 0; }
+            to { width: 100%; }
+        }
+
+        @keyframes blink {
+            0%, 50% { border-color: var(--neon-cyan); }
+            51%, 100% { border-color: transparent; }
+        }
+
+        /* Technology tags */
+        .tech-specs {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.5rem;
+            margin-top: 1rem;
+        }
+
+        .spec-tag {
+            background: linear-gradient(135deg, var(--neon-cyan), var(--neon-blue));
+            color: #000 !important;
+            padding: 0.3rem 0.8rem;
+            border-radius: 15px;
+            font-size: 0.8rem;
+            font-weight: 600;
+            letter-spacing: 0.5px;
+            box-shadow: 0 2px 10px rgba(77, 208, 225, 0.3);
+        }
+
+        /* Progress bar animation */
+        .progress-bar {
+            width: 100%;
+            height: 6px;
+            background: rgba(255, 255, 255, 0.1);
+            border-radius: 3px;
+            overflow: hidden;
+            margin-top: 1rem;
+        }
+
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(90deg, var(--neon-purple), var(--neon-cyan), var(--neon-green));
+            background-size: 200% 100%;
+            border-radius: 3px;
+            animation: progressMove 2s ease-in-out infinite;
+            width: 75%;
+        }
+
+        @keyframes progressMove {
+            0% { background-position: -200% 0; }
+            100% { background-position: 200% 0; }
+        }
+
+        /* Code preview area */
+        .code-preview {
+            background: rgba(0, 0, 0, 0.4);
+            border: 1px solid var(--neon-green);
+            border-radius: 10px;
+            padding: 1rem;
+            margin-top: 1rem;
+            font-family: 'JetBrains Mono', monospace;
+        }
+
+        .code-line {
+            font-size: 0.85rem;
+            line-height: 1.6;
+            margin-bottom: 0.5rem;
+            color: var(--neon-green) !important;
+        }
+
+        .code-line.generating {
+            color: var(--neon-cyan) !important;
+            animation: textGlow 2s ease-in-out infinite;
+        }
+
+        @keyframes textGlow {
+            0%, 100% { text-shadow: 0 0 5px var(--neon-cyan); }
+            50% { text-shadow: 0 0 15px var(--neon-cyan), 0 0 25px var(--neon-cyan); }
+        }
+
+        /* Progress dots */
+        .code-progress {
+            margin-top: 1rem;
+        }
+
+        .progress-dots {
+            display: flex;
+            gap: 0.5rem;
+            justify-content: center;
+        }
+
+        .dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.3);
+            transition: all 0.3s ease;
+        }
+
+        .dot.active {
+            background: var(--neon-green);
+            box-shadow: 0 0 10px var(--neon-green);
+            animation: dotPulse 1.5s ease-in-out infinite;
+        }
+
+        @keyframes dotPulse {
+            0%, 100% { transform: scale(1); }
+            50% { transform: scale(1.3); }
+        }
+
+        /* Technology stack display */
+        .tech-stack {
+            display: flex;
+            flex-direction: column;
+            gap: 0.8rem;
+        }
+
+        .stack-item {
+            display: flex;
+            align-items: center;
+            gap: 0.8rem;
+            padding: 0.8rem;
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 10px;
+            transition: all 0.3s ease;
+        }
+
+        .stack-item:hover {
+            background: rgba(255, 255, 255, 0.1);
+            border-color: var(--neon-blue);
+            transform: translateX(5px);
+        }
+
+        .stack-icon {
+            font-size: 1.2rem;
+            filter: drop-shadow(0 0 8px rgba(100, 181, 246, 0.6));
+        }
+
+        .stack-name {
+            font-family: 'JetBrains Mono', monospace !important;
+            color: var(--text-primary) !important;
+            font-weight: 600 !important;
+            font-size: 0.9rem;
+        }
+
+        /* Responsive design */
+        @media (max-width: 768px) {
+            .main-header {
+                padding: 2.5rem 1.5rem;
+                margin-bottom: 2rem;
+                border-radius: 20px;
+            }
+
+            .main-header h1 {
+                font-size: 2.5rem !important;
+            }
+
+            .main-header h3 {
+                font-size: 1rem !important;
+                letter-spacing: 1.5px !important;
+            }
+
+            .main-header p {
+                font-size: 0.8rem !important;
+                letter-spacing: 0.5px !important;
+            }
+
+            .ai-capabilities-section {
+                padding: 1.5rem 1rem;
+                margin: 1.5rem 0;
+                border-radius: 15px;
+            }
+
+            .capabilities-title {
+                font-size: 1.6rem !important;
+            }
+
+            .capabilities-subtitle {
+                font-size: 0.8rem !important;
+                letter-spacing: 1px !important;
+            }
+
+            .feature-card {
+                padding: 1.5rem;
+                margin: 1rem 0;
+                height: auto;
+                min-height: 350px;
+                border-radius: 15px;
+            }
+
+            .neural-network {
+                top: 0.5rem;
+                right: 1rem;
+            }
+
+            .typing-text {
+                white-space: normal;
+                border-right: none;
+                animation: none;
+                font-size: 0.85rem !important;
+            }
+
+            .feature-icon {
+                font-size: 2.5rem;
+            }
+
+            .feature-title {
+                font-size: 1.1rem !important;
+            }
+        }
+        /* ================================
+           CONTENT COMPONENT STYLES
+           ================================ */
+
+        /* Feature Flow Animation */
+        .feature-flow {
+            display: flex;
+            align-items: center;
+            gap: 1rem;
+            flex-wrap: wrap;
+            margin-top: 1.5rem;
+        }
+
+        .flow-step {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.8rem 1.2rem;
+            background: rgba(77, 208, 225, 0.1);
+            border: 1px solid rgba(77, 208, 225, 0.3);
+            border-radius: 25px;
+            transition: all 0.3s ease;
+        }
+
+        .flow-step.active {
+            background: rgba(77, 208, 225, 0.2);
+            border-color: var(--neon-cyan);
+            box-shadow: 0 0 15px rgba(77, 208, 225, 0.3);
+        }
+
+        .flow-icon {
+            font-size: 1.2rem;
+        }
+
+        .flow-arrow {
+            color: var(--neon-cyan);
+            font-size: 1.2rem;
+            animation: arrowFlow 2s ease-in-out infinite;
+        }
+
+        @keyframes arrowFlow {
+            0%, 100% { transform: translateX(0); opacity: 0.7; }
+            50% { transform: translateX(5px); opacity: 1; }
+        }
+
+        /* Code Simulation */
+        .code-simulation {
+            background: rgba(0, 0, 0, 0.6);
+            border: 1px solid var(--neon-cyan);
+            border-radius: 12px;
+            padding: 1.5rem;
+            font-family: 'JetBrains Mono', monospace;
+            width: 100%;
+            max-width: 400px;
+        }
+
+        .code-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 1rem;
+            padding-bottom: 0.5rem;
+            border-bottom: 1px solid rgba(77, 208, 225, 0.3);
+        }
+
+        .code-lang {
+            color: var(--neon-cyan);
+            font-weight: 600;
+            font-size: 0.9rem;
+        }
+
+        .code-status.generating {
+            color: var(--neon-green);
+            font-size: 0.8rem;
+            animation: statusPulse 2s ease-in-out infinite;
+        }
+
+        @keyframes statusPulse {
+            0%, 100% { opacity: 0.7; }
+            50% { opacity: 1; }
+        }
+
+        .code-lines {
+            display: flex;
+            flex-direction: column;
+            gap: 0.3rem;
+        }
+
+        .code-line {
+            color: var(--text-secondary);
+            font-size: 0.85rem;
+            line-height: 1.4;
+            opacity: 0;
+        }
+
+        .code-line.typing {
+            animation: typeIn 0.8s ease-out forwards;
+        }
+
+        .code-line.delay-1 { animation-delay: 0.8s; }
+        .code-line.delay-2 { animation-delay: 1.6s; }
+        .code-line.delay-3 { animation-delay: 2.4s; }
+        .code-line.delay-4 { animation-delay: 3.2s; }
+
+        @keyframes typeIn {
+            0% {
+                opacity: 0;
+                transform: translateX(-10px);
+            }
+            100% {
+                opacity: 1;
+                transform: translateX(0);
+            }
+        }
+
+        /* Agent Grid */
+        .agent-grid {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 1rem;
+            margin-top: 1.5rem;
+        }
+
+        .agent-card {
+            padding: 1rem;
+            background: rgba(186, 104, 200, 0.1);
+            border: 1px solid rgba(186, 104, 200, 0.3);
+            border-radius: 12px;
+            text-align: center;
+            transition: all 0.3s ease;
+        }
+
+        .agent-card.active {
+            background: rgba(186, 104, 200, 0.2);
+            border-color: var(--neon-purple);
+            box-shadow: 0 0 15px rgba(186, 104, 200, 0.3);
+        }
+
+        .agent-avatar {
+            font-size: 1.5rem;
+            margin-bottom: 0.5rem;
+        }
+
+        .agent-card h4 {
+            color: var(--text-primary) !important;
+            font-size: 0.9rem !important;
+            font-weight: 600 !important;
+            margin-bottom: 0.3rem !important;
+        }
+
+        .agent-card p {
+            color: var(--text-secondary) !important;
+            font-size: 0.75rem !important;
+            margin: 0 !important;
+        }
+
+        /* Collaboration Visualization */
+        .collaboration-viz {
+            position: relative;
+            width: 300px;
+            height: 300px;
+            margin: 0 auto;
+        }
+
+        .collaboration-center {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            text-align: center;
+            z-index: 2;
+        }
+
+        .center-node {
+            width: 60px;
+            height: 60px;
+            background: linear-gradient(135deg, var(--neon-purple), var(--neon-cyan));
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.5rem;
+            margin: 0 auto 0.5rem;
+            animation: centerRotate 4s linear infinite;
+        }
+
+        .collaboration-center span {
+            color: var(--text-primary) !important;
+            font-size: 0.8rem !important;
+            font-weight: 600 !important;
+        }
+
+        .collaboration-agents {
+            position: relative;
+            width: 100%;
+            height: 100%;
+        }
+
+        .collab-agent {
+            position: absolute;
+            width: 50px;
+            height: 50px;
+            background: rgba(77, 208, 225, 0.2);
+            border: 2px solid var(--neon-cyan);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.2rem;
+        }
+
+        .pulse-ring {
+            position: absolute;
+            width: 60px;
+            height: 60px;
+            border: 2px solid var(--neon-cyan);
+            border-radius: 50%;
+            top: -5px;
+            left: -5px;
+            animation: pulseRing 2s ease-out infinite;
+        }
+
+        .agent-pos-1 {
+            top: 20px;
+            left: 50%;
+            transform: translateX(-50%);
+            animation-delay: 0s;
+        }
+
+        .agent-pos-2 {
+            top: 50%;
+            right: 20px;
+            transform: translateY(-50%);
+            animation-delay: 0.5s;
+        }
+
+        .agent-pos-3 {
+            bottom: 20px;
+            left: 50%;
+            transform: translateX(-50%);
+            animation-delay: 1s;
+        }
+
+        .agent-pos-4 {
+            top: 50%;
+            left: 20px;
+            transform: translateY(-50%);
+            animation-delay: 1.5s;
+        }
+
+        @keyframes centerRotate {
+            0% { transform: translate(-50%, -50%) rotate(0deg); }
+            100% { transform: translate(-50%, -50%) rotate(360deg); }
+        }
+
+        @keyframes pulseRing {
+            0% {
+                transform: scale(0.8);
+                opacity: 1;
+            }
+            100% {
+                transform: scale(1.4);
+                opacity: 0;
+            }
+        }
+
+        /* Vision Demo */
+        .vision-demo {
+            margin-top: 1.5rem;
+            padding: 1.5rem;
+            background: rgba(129, 199, 132, 0.1);
+            border: 1px solid rgba(129, 199, 132, 0.3);
+            border-radius: 15px;
+        }
+
+        .demo-input {
+            display: flex;
+            align-items: center;
+            gap: 1rem;
+            padding: 1rem;
+            background: rgba(0, 0, 0, 0.3);
+            border-radius: 10px;
+            margin-bottom: 1rem;
+        }
+
+        .input-icon {
+            font-size: 1.5rem;
+        }
+
+        .input-text {
+            flex: 1;
+            color: var(--neon-green) !important;
+            font-family: 'JetBrains Mono', monospace !important;
+            font-size: 0.9rem !important;
+        }
+
+        .input-text.typing {
+            border-right: 2px solid var(--neon-green);
+            animation: inputTyping 4s steps(60, end), inputBlink 1s infinite;
+        }
+
+        @keyframes inputTyping {
+            from { width: 0; }
+            to { width: 100%; }
+        }
+
+        @keyframes inputBlink {
+            0%, 50% { border-color: var(--neon-green); }
+            51%, 100% { border-color: transparent; }
+        }
+
+        .demo-arrow {
+            text-align: center;
+            font-size: 1.5rem;
+            color: var(--neon-green);
+            margin: 1rem 0;
+            animation: arrowBounce 2s ease-in-out infinite;
+        }
+
+        @keyframes arrowBounce {
+            0%, 100% { transform: translateY(0); }
+            50% { transform: translateY(5px); }
+        }
+
+        .demo-output {
+            padding: 1rem;
+            background: rgba(0, 0, 0, 0.3);
+            border-radius: 10px;
+        }
+
+        .output-items {
+            display: flex;
+            flex-direction: column;
+            gap: 0.5rem;
+        }
+
+        .output-item {
+            padding: 0.5rem 1rem;
+            background: rgba(129, 199, 132, 0.2);
+            border: 1px solid rgba(129, 199, 132, 0.4);
+            border-radius: 8px;
+            color: var(--neon-green) !important;
+            font-size: 0.85rem !important;
+            animation: itemAppear 0.8s ease-out forwards;
+            opacity: 0;
+        }
+
+        .output-item:nth-child(1) { animation-delay: 0.5s; }
+        .output-item:nth-child(2) { animation-delay: 1s; }
+        .output-item:nth-child(3) { animation-delay: 1.5s; }
+        .output-item:nth-child(4) { animation-delay: 2s; }
+
+        @keyframes itemAppear {
+            0% {
+                opacity: 0;
+                transform: translateX(-20px);
+            }
+            100% {
+                opacity: 1;
+                transform: translateX(0);
+            }
+        }
+
+        /* Future Timeline */
+        .future-timeline {
+            display: flex;
+            flex-direction: column;
+            gap: 1.5rem;
+            padding: 1rem;
+            max-width: 300px;
+        }
+
+        .timeline-item {
+            display: flex;
+            align-items: center;
+            gap: 1rem;
+            padding: 1rem;
+            border-radius: 12px;
+            transition: all 0.3s ease;
+        }
+
+        .timeline-item.completed {
+            background: rgba(77, 208, 225, 0.1);
+            border: 1px solid rgba(77, 208, 225, 0.3);
+        }
+
+        .timeline-item.active {
+            background: rgba(129, 199, 132, 0.1);
+            border: 1px solid rgba(129, 199, 132, 0.3);
+            box-shadow: 0 0 15px rgba(129, 199, 132, 0.3);
+        }
+
+        .timeline-item.future {
+            background: rgba(186, 104, 200, 0.1);
+            border: 1px solid rgba(186, 104, 200, 0.3);
+            opacity: 0.7;
+        }
+
+        .timeline-marker {
+            width: 40px;
+            height: 40px;
+            background: var(--card-bg);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.2rem;
+            flex-shrink: 0;
+        }
+
+        .timeline-content h4 {
+            color: var(--text-primary) !important;
+            font-size: 1rem !important;
+            font-weight: 600 !important;
+            margin-bottom: 0.2rem !important;
+        }
+
+        .timeline-content p {
+            color: var(--text-secondary) !important;
+            font-size: 0.8rem !important;
+            margin: 0 !important;
+        }
+
+        /* Community Features */
+        .community-features {
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+            margin-top: 1.5rem;
+        }
+
+        .community-feature {
+            display: flex;
+            align-items: flex-start;
+            gap: 1rem;
+            padding: 1rem;
+            background: rgba(100, 181, 246, 0.1);
+            border: 1px solid rgba(100, 181, 246, 0.3);
+            border-radius: 12px;
+            transition: all 0.3s ease;
+        }
+
+        .community-feature:hover {
+            background: rgba(100, 181, 246, 0.15);
+            border-color: var(--neon-blue);
+        }
+
+        .feature-icon-small {
+            font-size: 1.5rem;
+            flex-shrink: 0;
+            margin-top: 0.2rem;
+        }
+
+        .feature-text h4 {
+            color: var(--text-primary) !important;
+            font-size: 1rem !important;
+            font-weight: 600 !important;
+            margin-bottom: 0.3rem !important;
+        }
+
+        .feature-text p {
+            color: var(--text-secondary) !important;
+            font-size: 0.85rem !important;
+            line-height: 1.4 !important;
+            margin: 0 !important;
+        }
+
+        /* Tech Ecosystem */
+        .tech-ecosystem {
+            position: relative;
+            width: 300px;
+            height: 300px;
+            margin: 0 auto;
+        }
+
+        .ecosystem-center {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            text-align: center;
+            z-index: 2;
+        }
+
+        .center-logo {
+            width: 60px;
+            height: 60px;
+            background: linear-gradient(135deg, var(--neon-blue), var(--neon-cyan));
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.5rem;
+            margin: 0 auto 0.5rem;
+            animation: logoFloat 3s ease-in-out infinite;
+        }
+
+        .ecosystem-center span {
+            color: var(--text-primary) !important;
+            font-size: 0.9rem !important;
+            font-weight: 600 !important;
+        }
+
+        .ecosystem-ring {
+            position: relative;
+            width: 100%;
+            height: 100%;
+        }
+
+        .ecosystem-item {
+            position: absolute;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 0.3rem;
+            padding: 0.8rem;
+            background: rgba(100, 181, 246, 0.1);
+            border: 1px solid rgba(100, 181, 246, 0.3);
+            border-radius: 12px;
+            animation: ecosystemOrbit 8s linear infinite;
+        }
+
+        .ecosystem-item.item-1 {
+            top: 10px;
+            left: 50%;
+            transform: translateX(-50%);
+        }
+
+        .ecosystem-item.item-2 {
+            top: 50%;
+            right: 10px;
+            transform: translateY(-50%);
+        }
+
+        .ecosystem-item.item-3 {
+            bottom: 10px;
+            left: 50%;
+            transform: translateX(-50%);
+        }
+
+        .ecosystem-item.item-4 {
+            top: 50%;
+            left: 10px;
+            transform: translateY(-50%);
+        }
+
+        .item-icon {
+            font-size: 1.2rem;
+        }
+
+        .ecosystem-item span {
+            color: var(--text-primary) !important;
+            font-size: 0.7rem !important;
+            font-weight: 600 !important;
+            text-align: center;
+        }
+
+        @keyframes logoFloat {
+            0%, 100% {
+                transform: translate(-50%, -50%) scale(1);
+            }
+            50% {
+                transform: translate(-50%, -50%) scale(1.05);
+            }
+        }
+
+        @keyframes ecosystemOrbit {
+            0% {
+                box-shadow: 0 0 10px rgba(100, 181, 246, 0.3);
+            }
+            50% {
+                box-shadow: 0 0 20px rgba(100, 181, 246, 0.5);
+            }
+            100% {
+                box-shadow: 0 0 10px rgba(100, 181, 246, 0.3);
+            }
+        }
+
+        /* Responsive adjustments for vertical cards */
+        @media (max-width: 768px) {
+            .feature-content {
+                flex-direction: column;
+                gap: 2rem;
+            }
+
+            .feature-header {
+                flex-direction: column;
+                text-align: center;
+                gap: 1rem;
+            }
+
+            .feature-stats {
+                flex-direction: row;
+                justify-content: center;
+            }
+
+            .collaboration-viz,
+            .tech-ecosystem {
+                width: 250px;
+                height: 250px;
+            }
+        }
+
+        /* Additional sidebar styles for newer Streamlit versions */
+        /* Cover any new sidebar containers or data-testid selectors */
+        [data-testid="stSidebar"],
+        [data-testid="stSidebarNav"],
+        [data-testid="stSidebarNavItems"],
+        .stSidebar,
+        .sidebar,
+        .sidebar-content,
+        section[data-testid="stSidebar"] {
+            background: linear-gradient(180deg, #0d1117 0%, #161b22 50%, #21262d 100%) !important;
+            border-right: 2px solid var(--neon-cyan) !important;
+            box-shadow: 0 0 20px rgba(77, 208, 225, 0.3) !important;
+            color: var(--text-primary) !important;
+        }
+
+        /* Light mode override for new sidebar selectors */
+        @media (prefers-color-scheme: light) {
+            [data-testid="stSidebar"],
+            [data-testid="stSidebarNav"],
+            [data-testid="stSidebarNavItems"],
+            .stSidebar,
+            .sidebar,
+            .sidebar-content,
+            section[data-testid="stSidebar"] {
+                background: linear-gradient(180deg, #0d1117 0%, #161b22 50%, #21262d 100%) !important;
+                border-right: 2px solid var(--neon-cyan) !important;
+                box-shadow: 0 0 20px rgba(77, 208, 225, 0.3) !important;
+                color: var(--text-primary) !important;
+            }
+        }
+
+        /* Alternative light theme detection for new sidebar selectors */
+        [data-theme="light"] [data-testid="stSidebar"],
+        [data-theme="light"] [data-testid="stSidebarNav"],
+        [data-theme="light"] [data-testid="stSidebarNavItems"],
+        [data-theme="light"] .stSidebar,
+        [data-theme="light"] .sidebar,
+        [data-theme="light"] .sidebar-content,
+        [data-theme="light"] section[data-testid="stSidebar"] {
+            background: linear-gradient(180deg, #0d1117 0%, #161b22 50%, #21262d 100%) !important;
+            border-right: 2px solid var(--neon-cyan) !important;
+            box-shadow: 0 0 20px rgba(77, 208, 225, 0.3) !important;
+            color: var(--text-primary) !important;
+        }
+
+        /* Force all text in sidebar containers to use dark theme colors */
+        [data-testid="stSidebar"] *,
+        [data-testid="stSidebarNav"] *,
+        [data-testid="stSidebarNavItems"] *,
+        .stSidebar *,
+        .sidebar *,
+        .sidebar-content *,
+        section[data-testid="stSidebar"] * {
+            color: var(--text-primary) !important;
+        }
+
+        /* Light mode: Force all text in sidebar containers to use dark theme colors */
+        @media (prefers-color-scheme: light) {
+            [data-testid="stSidebar"] *,
+            [data-testid="stSidebarNav"] *,
+            [data-testid="stSidebarNavItems"] *,
+            .stSidebar *,
+            .sidebar *,
+            .sidebar-content *,
+            section[data-testid="stSidebar"] * {
+                color: var(--text-primary) !important;
+            }
+        }
+
+        /* Alternative light theme detection for sidebar text */
+        [data-theme="light"] [data-testid="stSidebar"] *,
+        [data-theme="light"] [data-testid="stSidebarNav"] *,
+        [data-theme="light"] [data-testid="stSidebarNavItems"] *,
+        [data-theme="light"] .stSidebar *,
+        [data-theme="light"] .sidebar *,
+        [data-theme="light"] .sidebar-content *,
+        [data-theme="light"] section[data-testid="stSidebar"] * {
+            color: var(--text-primary) !important;
+        }
+
+    </style>
+    """

projects/ui/DeepCode/utils/__init__.py

@@ -0,0 +1,17 @@
+"""
+Utils package for paper processing tools.
+"""
+
+from .file_processor import FileProcessor
+from .dialogue_logger import (
+    DialogueLogger,
+    create_dialogue_logger,
+    extract_paper_id_from_path,
+)
+
+__all__ = [
+    "FileProcessor",
+    "DialogueLogger",
+    "create_dialogue_logger",
+    "extract_paper_id_from_path",
+]

projects/ui/DeepCode/utils/cli_interface.py

@@ -0,0 +1,459 @@
+#!/usr/bin/env python3
+"""
+Professional CLI Interface Module
+专业CLI界面模块 - 包含logo、颜色定义和界面组件
+"""
+
+import os
+import time
+import platform
+from pathlib import Path
+from typing import Optional
+import tkinter as tk
+from tkinter import filedialog
+
+
+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:
+    """Professional CLI interface with modern styling"""
+
+    def __init__(self):
+        self.uploaded_file = None
+        self.is_running = True
+
+        # Check tkinter availability
+        self.tkinter_available = True
+        try:
+            import tkinter as tk
+
+            # Test if tkinter can create a window (some systems have tkinter but no display)
+            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 a beautiful ASCII logo with gradient colors and tech elements"""
+        # 确保每行总共79个字符（不包括颜色代码），边框完美对齐
+        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.YELLOW}┌─────────────────────────────────────────────────────────────────────────┐{Colors.CYAN}   ║
+║  {Colors.BOLD}{Colors.YELLOW}│  🤖 AI-POWERED RESEARCH PAPER REPRODUCTION ENGINE 🚀                  │{Colors.CYAN}   ║
+║  {Colors.BOLD}{Colors.YELLOW}│  ⚡ INTELLIGENT • AUTOMATED • CUTTING-EDGE ⚡                        │{Colors.CYAN}   ║
+║  {Colors.BOLD}{Colors.YELLOW}└─────────────────────────────────────────────────────────────────────────┘{Colors.CYAN}   ║
+║                                                                               ║
+║  {Colors.BOLD}{Colors.GREEN}💎 CORE CAPABILITIES:{Colors.ENDC}                                                        {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Neural PDF Analysis & Code Extraction                                 {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Advanced Document Processing Engine                                   {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Multi-Format Support (PDF•DOCX•PPTX•HTML)                           {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Smart File Upload Interface                                          {Colors.CYAN}║
+║    {Colors.BOLD}{Colors.OKCYAN}▶ Automated Repository Management                                      {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.BOLD}{Colors.PURPLE}🔬 TECH STACK: Python•AI•MCP•Docling•LLM                                   {Colors.CYAN}║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(logo)
+
+    def print_welcome_banner(self):
+        """Print welcome banner with version info"""
+        banner = f"""
+{Colors.BOLD}{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                              WELCOME TO ReproAI                              ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║                                                                               ║
+║  {Colors.YELLOW}Version: 2.0.0 | Build: Professional Edition                                 {Colors.CYAN}║
+║  {Colors.GREEN}Status: Ready | Engine: Initialized                                          {Colors.CYAN}║
+║  {Colors.PURPLE}Author: AI Research Team | License: MIT                                      {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}🔍",
+        }
+
+        icon = status_styles.get(status_type, status_styles["info"])
+        print(f"{icon} {Colors.BOLD}{message}{Colors.ENDC}")
+
+    def create_menu(self):
+        """Create an interactive menu"""
+        menu = f"""
+{Colors.BOLD}{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                                MAIN MENU                                      ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║                                                                               ║
+║  {Colors.OKGREEN}🌐 [U] Process URL       {Colors.CYAN}│  {Colors.PURPLE}📁 [F] Upload File    {Colors.CYAN}│  {Colors.FAIL}❌ [Q] Quit{Colors.CYAN}         ║
+║                                                                               ║
+║  {Colors.YELLOW}📝 Enter a research paper URL (arXiv, IEEE, ACM, etc.)                      {Colors.CYAN}║
+║  {Colors.YELLOW}   or upload a PDF/DOC file for intelligent analysis                        {Colors.CYAN}║
+║                                                                               ║
+║  {Colors.OKCYAN}💡 Tip: Press 'F' to open file browser or 'U' to enter URL manually        {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]:
+        """Modern file upload interface using tkinter with cross-platform compatibility"""
+        # Check if tkinter is available
+        if not self.tkinter_available:
+            self.print_status("GUI file dialog not available on this system", "warning")
+            self.print_status("Using manual file path input instead", "info")
+            return self._get_manual_file_path()
+
+        def select_file():
+            try:
+                # Create a hidden root window
+                root = tk.Tk()
+                root.withdraw()  # Hide the main window
+
+                # Platform-specific configurations
+                system = platform.system()
+
+                if system == "Darwin":  # macOS
+                    # macOS specific settings
+                    try:
+                        root.call("wm", "attributes", ".", "-topmost", True)
+                    except Exception:
+                        pass
+
+                    # macOS compatible file types
+                    file_types = [
+                        ("PDF Files", ".pdf"),
+                        ("Word Documents", ".docx .doc"),
+                        ("PowerPoint Files", ".pptx .ppt"),
+                        ("HTML Files", ".html .htm"),
+                        ("Text Files", ".txt .md"),
+                        ("All Files", ".*"),
+                    ]
+                else:
+                    # Windows and Linux
+                    root.attributes("-topmost", True)
+
+                    # Windows/Linux compatible file types
+                    file_types = [
+                        ("PDF Files", "*.pdf"),
+                        ("Word Documents", "*.docx;*.doc"),
+                        ("PowerPoint Files", "*.pptx;*.ppt"),
+                        ("HTML Files", "*.html;*.htm"),
+                        ("Text Files", "*.txt;*.md"),
+                        ("All Files", "*.*"),
+                    ]
+
+                # Set window title
+                root.title("Repro-AI - File Selector")
+
+                try:
+                    # Open file dialog with platform-appropriate settings
+                    file_path = filedialog.askopenfilename(
+                        title="Select Research Paper File",
+                        filetypes=file_types,
+                        initialdir=os.getcwd(),
+                    )
+                except Exception as e:
+                    self.print_status(f"File dialog error: {str(e)}", "error")
+                    return None
+                finally:
+                    # Clean up
+                    try:
+                        root.destroy()
+                    except Exception:
+                        pass
+
+                return file_path
+
+            except Exception as e:
+                # Fallback: destroy root if it exists
+                try:
+                    if "root" in locals():
+                        root.destroy()
+                except Exception:
+                    pass
+
+                # Print error and suggest alternative
+                self.print_status(f"GUI file dialog failed: {str(e)}", "error")
+                self.print_status(
+                    "Please use manual file path input instead", "warning"
+                )
+                return self._get_manual_file_path()
+
+        self.print_status("Opening file browser dialog...", "upload")
+        file_path = select_file()
+
+        if file_path:
+            # Validate file
+            if not os.path.exists(file_path):
+                self.print_status("File not found!", "error")
+                return None
+
+            file_size = os.path.getsize(file_path) / (1024 * 1024)  # Size in MB
+            file_ext = Path(file_path).suffix.lower()
+
+            # Display file info with beautiful formatting
+            file_name = Path(file_path).name
+            directory = str(Path(file_path).parent)
+
+            # Truncate long paths for display
+            if len(file_name) > 50:
+                display_name = file_name[:47] + "..."
+            else:
+                display_name = file_name
+
+            if len(directory) > 49:
+                display_dir = "..." + directory[-46:]
+            else:
+                display_dir = directory
+
+            print(f"""
+{Colors.OKGREEN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                               FILE SELECTED                                   ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║                                                                               ║
+║  {Colors.BOLD}📄 File Name:{Colors.ENDC} {Colors.CYAN}{display_name:<50}{Colors.OKGREEN}║
+║  {Colors.BOLD}📁 Directory:{Colors.ENDC} {Colors.YELLOW}{display_dir:<49}{Colors.OKGREEN}║
+║  {Colors.BOLD}📊 File Size:{Colors.ENDC} {Colors.PURPLE}{file_size:.2f} MB{Colors.OKGREEN}                                      ║
+║  {Colors.BOLD}🔖 File Type:{Colors.ENDC} {Colors.MAGENTA}{file_ext.upper():<50}{Colors.OKGREEN}║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+""")
+
+            self.print_status(f"File successfully selected: {file_name}", "success")
+            return file_path
+        else:
+            self.print_status("No file selected", "warning")
+            return None
+
+    def _get_manual_file_path(self) -> Optional[str]:
+        """Fallback method for manual file path input when GUI fails"""
+        print(
+            f"\n{Colors.BOLD}{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗"
+        )
+        print(
+            "║                           MANUAL FILE INPUT                                   ║"
+        )
+        print(
+            f"╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}"
+        )
+
+        print(f"\n{Colors.YELLOW}📝 Supported file types:{Colors.ENDC}")
+        print(f"   {Colors.CYAN}• PDF files (.pdf)")
+        print(f"   {Colors.CYAN}• Word documents (.docx, .doc)")
+        print(f"   {Colors.CYAN}• PowerPoint files (.pptx, .ppt)")
+        print(f"   {Colors.CYAN}• HTML files (.html, .htm)")
+        print(f"   {Colors.CYAN}• Text files (.txt, .md){Colors.ENDC}")
+
+        print(
+            f"\n{Colors.BOLD}{Colors.OKCYAN}📁 Enter file path (or drag & drop): {Colors.ENDC}",
+            end="",
+        )
+        file_path = input().strip()
+
+        # Clean up the path (remove quotes if present)
+        file_path = file_path.strip("\"'")
+
+        if file_path:
+            # Expand user directory if needed
+            file_path = os.path.expanduser(file_path)
+
+            # Check if file exists
+            if os.path.exists(file_path):
+                self.print_status(
+                    f"File found: {os.path.basename(file_path)}", "success"
+                )
+                return file_path
+            else:
+                self.print_status("File not found at the specified path", "error")
+                return None
+        else:
+            self.print_status("No file path provided", "warning")
+            return None
+
+    def get_url_input(self) -> str:
+        """Get URL input with validation and examples"""
+        print(
+            f"\n{Colors.BOLD}{Colors.CYAN}╔═══════════════════════════════════════════════════════════════════════════════╗"
+        )
+        print(
+            "║                              URL INPUT                                        ║"
+        )
+        print(
+            f"╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}"
+        )
+
+        print(f"\n{Colors.YELLOW}📝 Supported URL Examples:{Colors.ENDC}")
+        print(f"   {Colors.CYAN}• arXiv: https://arxiv.org/pdf/2403.00813")
+        print(f"   {Colors.CYAN}• arXiv: @https://arxiv.org/pdf/2403.00813")
+        print(f"   {Colors.CYAN}• IEEE:  https://ieeexplore.ieee.org/document/...")
+        print(f"   {Colors.CYAN}• ACM:   https://dl.acm.org/doi/...")
+        print(
+            f"   {Colors.CYAN}• Direct PDF: https://example.com/paper.pdf{Colors.ENDC}"
+        )
+
+        print(
+            f"\n{Colors.BOLD}{Colors.OKCYAN}🌐 Enter paper URL: {Colors.ENDC}", end=""
+        )
+        url = input().strip()
+
+        if url:
+            # Basic URL validation
+            if any(
+                domain in url.lower()
+                for domain in ["arxiv.org", "ieee", "acm.org", ".pdf", "researchgate"]
+            ):
+                self.print_status(f"URL received: {url}", "success")
+                return url
+            else:
+                self.print_status("URL appears valid, proceeding...", "info")
+                return url
+        else:
+            self.print_status("No URL provided", "warning")
+            return ""
+
+    def show_progress_bar(self, message: str, duration: float = 2.0):
+        """Show a progress animation with enhanced styling"""
+        print(f"\n{Colors.YELLOW}{message}{Colors.ENDC}")
+
+        # Progress bar animation with different styles
+        bar_length = 50
+        for i in range(bar_length + 1):
+            percent = (i / bar_length) * 100
+            filled = "█" * i
+            empty = "░" * (bar_length - i)
+
+            # Color gradient effect
+            if percent < 33:
+                color = Colors.FAIL
+            elif percent < 66:
+                color = Colors.WARNING
+            else:
+                color = Colors.OKGREEN
+
+            print(
+                f"\r{color}[{filled}{empty}] {percent:6.1f}%{Colors.ENDC}",
+                end="",
+                flush=True,
+            )
+            time.sleep(duration / bar_length)
+
+        print(f"\n{Colors.OKGREEN}✅ {message} completed!{Colors.ENDC}\n")
+
+    def show_spinner(self, message: str, duration: float = 1.0):
+        """Show a spinner animation"""
+        spinner_chars = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+        end_time = time.time() + duration
+
+        while time.time() < end_time:
+            for char in spinner_chars:
+                print(
+                    f"\r{Colors.CYAN}{char} {Colors.BOLD}{message}{Colors.ENDC}",
+                    end="",
+                    flush=True,
+                )
+                time.sleep(0.1)
+                if time.time() >= end_time:
+                    break
+
+        print(f"\r{Colors.OKGREEN}✅ {Colors.BOLD}{message} - Done!{Colors.ENDC}")
+
+    def print_results_header(self):
+        """Print results section header"""
+        header = f"""
+{Colors.OKGREEN}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                             PROCESSING RESULTS                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(header)
+
+    def print_error_box(self, title: str, error_msg: str):
+        """Print error message in a styled box"""
+        print(f"""
+{Colors.FAIL}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                                  ERROR                                        ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║                                                                               ║
+║  {Colors.BOLD}Title: {title:<66}{Colors.FAIL}║
+║  {Colors.BOLD}Error: {error_msg:<66}{Colors.FAIL}║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+""")
+
+    def print_goodbye(self):
+        """Print goodbye message"""
+        goodbye = f"""
+{Colors.BOLD}{Colors.YELLOW}╔═══════════════════════════════════════════════════════════════════════════════╗
+║                                GOODBYE!                                       ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║                                                                               ║
+║  {Colors.CYAN}Thank you for using ReproAI!                                               {Colors.YELLOW}║
+║  {Colors.GREEN}🌟 Star us on GitHub: https://github.com/your-repo                        {Colors.YELLOW}║
+║  {Colors.PURPLE}📧 Contact: support@reproai.com                                          {Colors.YELLOW}║
+║  {Colors.MAGENTA}🐛 Report issues: https://github.com/your-repo/issues                    {Colors.YELLOW}║
+║                                                                               ║
+║  {Colors.OKGREEN}✨ Happy coding! See you next time! ✨                                   {Colors.YELLOW}║
+║                                                                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝{Colors.ENDC}
+"""
+        print(goodbye)
+
+    def ask_continue(self) -> bool:
+        """Ask user if they want to continue"""
+        print(
+            f"\n{Colors.BOLD}{Colors.CYAN}Press Enter to continue or 'q' to quit: {Colors.ENDC}",
+            end="",
+        )
+        choice = input().strip().lower()
+        return choice not in ["q", "quit", "exit"]

projects/ui/DeepCode/utils/dialogue_logger.py

@@ -0,0 +1,671 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Comprehensive Dialogue Logger for Code Implementation Workflow
+Logs complete conversation rounds with detailed formatting and paper-specific organization
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, List
+
+
+class DialogueLogger:
+    """
+    Comprehensive dialogue logger for code implementation workflow
+    Captures complete conversation rounds with proper formatting and organization
+    """
+
+    def __init__(self, paper_id: str, base_path: str = None):
+        """
+        Initialize dialogue logger for a specific paper
+
+        Args:
+            paper_id: Paper identifier (e.g., "1", "2", etc.)
+            base_path: Base path for logs (defaults to agent_folders structure)
+        """
+        self.paper_id = paper_id
+        self.base_path = (
+            base_path
+            or "/data2/bjdwhzzh/project-hku/Code-Agent2.0/Code-Agent/deepcode-mcp/agent_folders"
+        )
+        self.log_directory = os.path.join(
+            self.base_path, "papers", str(paper_id), "logs"
+        )
+
+        # Create log directory if it doesn't exist
+        Path(self.log_directory).mkdir(parents=True, exist_ok=True)
+
+        # Session tracking (initialize before log file creation)
+        self.round_counter = 0
+        self.session_start_time = datetime.now()
+        self.current_round_data = {}
+
+        # Generate log filename with timestamp
+        timestamp = self.session_start_time.strftime("%Y%m%d_%H%M%S")
+        self.log_filename = f"dialogue_log_{timestamp}.md"
+        self.log_filepath = os.path.join(self.log_directory, self.log_filename)
+
+        # Initialize log file with header
+        self._initialize_log_file()
+
+        print(f"📝 Dialogue Logger initialized for Paper {paper_id}")
+        print(f"📁 Log file: {self.log_filepath}")
+
+    def _initialize_log_file(self):
+        """Initialize the log file with header information"""
+        header = f"""# Code Implementation Dialogue Log
+
+**Paper ID:** {self.paper_id}
+**Session Start:** {self.session_start_time.strftime('%Y-%m-%d %H:%M:%S')}
+**Log File:** {self.log_filename}
+
+---
+
+## Session Overview
+
+This log contains the complete conversation rounds between the user and assistant during the code implementation workflow. Each round includes:
+
+- System prompts and user messages
+- Assistant responses with tool calls
+- Tool execution results
+- Implementation progress markers
+
+---
+
+"""
+        try:
+            with open(self.log_filepath, "w", encoding="utf-8") as f:
+                f.write(header)
+        except Exception as e:
+            print(f"⚠️ Failed to initialize log file: {e}")
+
+    def start_new_round(
+        self, round_type: str = "implementation", context: Dict[str, Any] = None
+    ):
+        """
+        Start a new dialogue round
+
+        Args:
+            round_type: Type of round (implementation, summary, error_handling, etc.)
+            context: Additional context information (may include 'iteration' to sync with workflow)
+        """
+        # Use iteration from context if provided, otherwise increment round_counter
+        if context and "iteration" in context:
+            self.round_counter = context["iteration"]
+        else:
+            self.round_counter += 1
+
+        self.current_round_data = {
+            "round_number": self.round_counter,
+            "round_type": round_type,
+            "start_time": datetime.now(),
+            "context": context or {},
+            "messages": [],
+            "tool_calls": [],
+            "results": [],
+            "metadata": {},
+        }
+
+        print(f"🔄 Starting Round {self.round_counter}: {round_type}")
+
+    def log_system_prompt(self, prompt: str, prompt_type: str = "system"):
+        """
+        Log system prompt or instructions
+
+        Args:
+            prompt: System prompt content
+            prompt_type: Type of prompt (system, instruction, etc.)
+        """
+        if not self.current_round_data:
+            self.start_new_round("system_setup")
+
+        self.current_round_data["messages"].append(
+            {
+                "role": "system",
+                "type": prompt_type,
+                "content": prompt,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+
+    def log_user_message(self, message: str, message_type: str = "user_input"):
+        """
+        Log user message
+
+        Args:
+            message: User message content
+            message_type: Type of message (user_input, feedback, guidance, etc.)
+        """
+        if not self.current_round_data:
+            self.start_new_round("user_interaction")
+
+        self.current_round_data["messages"].append(
+            {
+                "role": "user",
+                "type": message_type,
+                "content": message,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+
+    def log_assistant_response(
+        self, response: str, response_type: str = "assistant_response"
+    ):
+        """
+        Log assistant response
+
+        Args:
+            response: Assistant response content
+            response_type: Type of response (assistant_response, analysis, etc.)
+        """
+        if not self.current_round_data:
+            self.start_new_round("assistant_interaction")
+
+        self.current_round_data["messages"].append(
+            {
+                "role": "assistant",
+                "type": response_type,
+                "content": response,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+
+    def log_tool_calls(self, tool_calls: List[Dict[str, Any]]):
+        """
+        Log tool calls made by the assistant
+
+        Args:
+            tool_calls: List of tool calls with id, name, and input
+        """
+        if not self.current_round_data:
+            self.start_new_round("tool_execution")
+
+        for tool_call in tool_calls:
+            self.current_round_data["tool_calls"].append(
+                {
+                    "id": tool_call.get("id", ""),
+                    "name": tool_call.get("name", ""),
+                    "input": tool_call.get("input", {}),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+
+    def log_tool_results(self, tool_results: List[Dict[str, Any]]):
+        """
+        Log tool execution results
+
+        Args:
+            tool_results: List of tool results with tool_name and result
+        """
+        if not self.current_round_data:
+            self.start_new_round("tool_results")
+
+        for result in tool_results:
+            self.current_round_data["results"].append(
+                {
+                    "tool_name": result.get("tool_name", ""),
+                    "result": result.get("result", ""),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+
+    def log_metadata(self, key: str, value: Any):
+        """
+        Log metadata information
+
+        Args:
+            key: Metadata key
+            value: Metadata value
+        """
+        if not self.current_round_data:
+            self.start_new_round("metadata")
+
+        self.current_round_data["metadata"][key] = value
+
+    def log_memory_optimization(
+        self,
+        messages_before: List[Dict],
+        messages_after: List[Dict],
+        optimization_stats: Dict[str, Any],
+        approach: str = "memory_optimization",
+    ):
+        """
+        Log memory optimization details including before/after message content
+
+        Args:
+            messages_before: Messages before optimization
+            messages_after: Messages after optimization
+            optimization_stats: Statistics about the optimization
+            approach: Optimization approach used
+        """
+        if not self.current_round_data:
+            self.start_new_round("memory_optimization")
+
+        # Calculate what was removed/kept
+        removed_count = len(messages_before) - len(messages_after)
+        compression_ratio = (
+            (removed_count / len(messages_before) * 100) if messages_before else 0
+        )
+
+        # Log the optimization details
+        optimization_data = {
+            "approach": approach,
+            "messages_before_count": len(messages_before),
+            "messages_after_count": len(messages_after),
+            "messages_removed_count": removed_count,
+            "compression_ratio": f"{compression_ratio:.1f}%",
+            "optimization_stats": optimization_stats,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+        # Store the optimization data
+        if "memory_optimizations" not in self.current_round_data:
+            self.current_round_data["memory_optimizations"] = []
+
+        self.current_round_data["memory_optimizations"].append(
+            {
+                "optimization_data": optimization_data,
+                "messages_before": messages_before,
+                "messages_after": messages_after,
+            }
+        )
+
+        # Log metadata
+        self.log_metadata("memory_optimization", optimization_data)
+
+        print(
+            f"🧹 Memory optimization logged: {len(messages_before)} → {len(messages_after)} messages ({compression_ratio:.1f}% compression)"
+        )
+
+    def complete_round(self, summary: str = "", status: str = "completed"):
+        """
+        Complete the current round and write to log file
+
+        Args:
+            summary: Round summary
+            status: Round completion status
+        """
+        if not self.current_round_data:
+            print("⚠️ No active round to complete")
+            return
+
+        self.current_round_data["end_time"] = datetime.now()
+        self.current_round_data["duration"] = (
+            self.current_round_data["end_time"] - self.current_round_data["start_time"]
+        ).total_seconds()
+        self.current_round_data["summary"] = summary
+        self.current_round_data["status"] = status
+
+        # Write round to log file
+        self._write_round_to_log()
+
+        print(f"✅ Round {self.round_counter} completed: {status}")
+
+        # Clear current round data
+        self.current_round_data = {}
+
+    def _write_round_to_log(self):
+        """Write the current round data to the log file in markdown format"""
+        try:
+            with open(self.log_filepath, "a", encoding="utf-8") as f:
+                round_data = self.current_round_data
+
+                # Round header
+                f.write(
+                    f"\n## Round {round_data['round_number']}: {round_data['round_type'].title()}\n\n"
+                )
+                f.write(
+                    f"**Start Time:** {round_data['start_time'].strftime('%Y-%m-%d %H:%M:%S')}\n"
+                )
+                f.write(
+                    f"**End Time:** {round_data['end_time'].strftime('%Y-%m-%d %H:%M:%S')}\n"
+                )
+                f.write(f"**Duration:** {round_data['duration']:.2f} seconds\n")
+                f.write(f"**Status:** {round_data['status']}\n\n")
+
+                # Context information
+                if round_data.get("context"):
+                    f.write("### Context\n\n")
+                    for key, value in round_data["context"].items():
+                        f.write(f"- **{key}:** {value}\n")
+                    f.write("\n")
+
+                # Messages
+                if round_data.get("messages"):
+                    f.write("### Messages\n\n")
+                    for i, msg in enumerate(round_data["messages"], 1):
+                        role_emoji = {
+                            "system": "🔧",
+                            "user": "👤",
+                            "assistant": "🤖",
+                        }.get(msg["role"], "📝")
+                        f.write(
+                            f"#### {role_emoji} {msg['role'].title()} Message {i}\n\n"
+                        )
+                        f.write(f"**Type:** {msg['type']}\n")
+                        f.write(f"**Timestamp:** {msg['timestamp']}\n\n")
+                        f.write("```\n")
+                        f.write(msg["content"])
+                        f.write("\n```\n\n")
+
+                # Tool calls
+                if round_data.get("tool_calls"):
+                    f.write("### Tool Calls\n\n")
+                    for i, tool_call in enumerate(round_data["tool_calls"], 1):
+                        f.write(f"#### 🛠️ Tool Call {i}: {tool_call['name']}\n\n")
+                        f.write(f"**ID:** {tool_call['id']}\n")
+                        f.write(f"**Timestamp:** {tool_call['timestamp']}\n\n")
+                        f.write("**Input:**\n")
+                        f.write("```json\n")
+                        f.write(
+                            json.dumps(tool_call["input"], indent=2, ensure_ascii=False)
+                        )
+                        f.write("\n```\n\n")
+
+                # Tool results
+                if round_data.get("results"):
+                    f.write("### Tool Results\n\n")
+                    for i, result in enumerate(round_data["results"], 1):
+                        f.write(f"#### 📊 Result {i}: {result['tool_name']}\n\n")
+                        f.write(f"**Timestamp:** {result['timestamp']}\n\n")
+                        f.write("**Result:**\n")
+                        f.write("```\n")
+                        f.write(str(result["result"]))
+                        f.write("\n```\n\n")
+
+                # Memory Optimizations
+                if round_data.get("memory_optimizations"):
+                    f.write("### Memory Optimizations\n\n")
+                    for i, opt in enumerate(round_data["memory_optimizations"], 1):
+                        opt_data = opt["optimization_data"]
+                        messages_before = opt["messages_before"]
+                        messages_after = opt["messages_after"]
+
+                        f.write(f"#### 🧹 Memory Optimization {i}\n\n")
+                        f.write(f"**Approach:** {opt_data['approach']}\n")
+                        f.write(
+                            f"**Messages Before:** {opt_data['messages_before_count']}\n"
+                        )
+                        f.write(
+                            f"**Messages After:** {opt_data['messages_after_count']}\n"
+                        )
+                        f.write(
+                            f"**Messages Removed:** {opt_data['messages_removed_count']}\n"
+                        )
+                        f.write(
+                            f"**Compression Ratio:** {opt_data['compression_ratio']}\n"
+                        )
+                        f.write(f"**Timestamp:** {opt_data['timestamp']}\n\n")
+
+                        # Show optimization stats
+                        if opt_data.get("optimization_stats"):
+                            f.write("**Optimization Statistics:**\n")
+                            f.write("```json\n")
+                            f.write(
+                                json.dumps(
+                                    opt_data["optimization_stats"],
+                                    indent=2,
+                                    ensure_ascii=False,
+                                )
+                            )
+                            f.write("\n```\n\n")
+
+                        # Show messages before optimization (limited to last 5 for readability)
+                        if messages_before:
+                            f.write("**Messages Before Optimization (last 5):**\n\n")
+                            for j, msg in enumerate(messages_before[-5:], 1):
+                                role = msg.get("role", "unknown")
+                                content = msg.get("content", "")
+                                # Truncate very long messages
+                                if len(content) > 3000:
+                                    content = content[:3000] + "...[truncated]"
+                                f.write(
+                                    f"- **{role} {j}:** {content[:3000]}{'...' if len(content) > 100 else ''}\n"
+                                )
+                            f.write("\n")
+
+                        # Show messages after optimization
+                        if messages_after:
+                            f.write("**Messages After Optimization:**\n\n")
+                            for j, msg in enumerate(messages_after, 1):
+                                role = msg.get("role", "unknown")
+                                content = msg.get("content", "")
+                                # Truncate very long messages
+                                if len(content) > 3000:
+                                    content = content[:3000] + "...[truncated]"
+                                f.write(
+                                    f"- **{role} {j}:** {content[:3000]}{'...' if len(content) > 100 else ''}\n"
+                                )
+                            f.write("\n")
+
+                        # Show what was removed
+                        if len(messages_before) > len(messages_after):
+                            removed_messages = (
+                                messages_before[: -len(messages_after)]
+                                if messages_after
+                                else messages_before
+                            )
+                            f.write(
+                                f"**Messages Removed ({len(removed_messages)}):**\n\n"
+                            )
+                            for j, msg in enumerate(
+                                removed_messages[-3:], 1
+                            ):  # Show last 3 removed
+                                role = msg.get("role", "unknown")
+                                content = msg.get("content", "")
+                                if len(content) > 3000:
+                                    content = content[:3000] + "...[truncated]"
+                                f.write(f"- **{role} {j}:** {content}\n")
+                            f.write("\n")
+
+                        f.write("\n")
+
+                # Metadata
+                if round_data.get("metadata"):
+                    f.write("### Metadata\n\n")
+                    for key, value in round_data["metadata"].items():
+                        if (
+                            key != "memory_optimization"
+                        ):  # Skip memory optimization metadata as it's shown above
+                            f.write(f"- **{key}:** {value}\n")
+                    f.write("\n")
+
+                # Summary
+                if round_data.get("summary"):
+                    f.write("### Summary\n\n")
+                    f.write(round_data["summary"])
+                    f.write("\n\n")
+
+                # Separator
+                f.write("---\n\n")
+
+        except Exception as e:
+            print(f"⚠️ Failed to write round to log: {e}")
+
+    def log_complete_exchange(
+        self,
+        system_prompt: str = "",
+        user_message: str = "",
+        assistant_response: str = "",
+        tool_calls: List[Dict] = None,
+        tool_results: List[Dict] = None,
+        round_type: str = "exchange",
+        context: Dict = None,
+        summary: str = "",
+    ):
+        """
+        Log a complete exchange in a single call
+
+        Args:
+            system_prompt: System prompt (optional)
+            user_message: User message
+            assistant_response: Assistant response
+            tool_calls: Tool calls made
+            tool_results: Tool execution results
+            round_type: Type of round
+            context: Additional context
+            summary: Round summary
+        """
+        self.start_new_round(round_type, context)
+
+        if system_prompt:
+            self.log_system_prompt(system_prompt)
+
+        if user_message:
+            self.log_user_message(user_message)
+
+        if assistant_response:
+            self.log_assistant_response(assistant_response)
+
+        if tool_calls:
+            self.log_tool_calls(tool_calls)
+
+        if tool_results:
+            self.log_tool_results(tool_results)
+
+        self.complete_round(summary)
+
+    def get_session_stats(self) -> Dict[str, Any]:
+        """Get session statistics"""
+        return {
+            "paper_id": self.paper_id,
+            "session_start": self.session_start_time.isoformat(),
+            "total_rounds": self.round_counter,
+            "log_file": self.log_filepath,
+            "session_duration": (
+                datetime.now() - self.session_start_time
+            ).total_seconds(),
+        }
+
+    def finalize_session(self, final_summary: str = ""):
+        """
+        Finalize the logging session
+
+        Args:
+            final_summary: Final session summary
+        """
+        try:
+            with open(self.log_filepath, "a", encoding="utf-8") as f:
+                f.write("\n## Session Summary\n\n")
+                f.write(f"**Total Rounds:** {self.round_counter}\n")
+                f.write(
+                    f"**Session Duration:** {(datetime.now() - self.session_start_time).total_seconds():.2f} seconds\n"
+                )
+                f.write(
+                    f"**End Time:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+                )
+
+                if final_summary:
+                    f.write("### Final Summary\n\n")
+                    f.write(final_summary)
+                    f.write("\n\n")
+
+                f.write("---\n\n")
+                f.write("*End of Session*\n")
+
+        except Exception as e:
+            print(f"⚠️ Failed to finalize session: {e}")
+
+        print(f"🎯 Session finalized: {self.round_counter} rounds logged")
+
+
+# Utility functions for easy integration
+def create_dialogue_logger(paper_id: str, base_path: str = None) -> DialogueLogger:
+    """
+    Create a dialogue logger for a specific paper
+
+    Args:
+        paper_id: Paper identifier
+        base_path: Base path for logs
+
+    Returns:
+        DialogueLogger instance
+    """
+    return DialogueLogger(paper_id, base_path)
+
+
+def extract_paper_id_from_path(path: str) -> str:
+    """
+    Extract paper ID from a file path
+
+    Args:
+        path: File path containing paper information
+
+    Returns:
+        Paper ID string
+    """
+    # Extract paper ID from path like "/data2/.../papers/1/initial_plan.txt"
+    parts = path.split("/")
+    for i, part in enumerate(parts):
+        if part == "papers" and i + 1 < len(parts):
+            return parts[i + 1]
+    return "unknown"
+
+
+# Example usage
+if __name__ == "__main__":
+    # Test the dialogue logger
+    logger = DialogueLogger("1")
+
+    # Log a complete exchange
+    logger.log_complete_exchange(
+        system_prompt="You are a code implementation assistant.",
+        user_message="Implement the transformer model",
+        assistant_response="I'll implement the transformer model step by step.",
+        tool_calls=[
+            {"id": "1", "name": "write_file", "input": {"filename": "transformer.py"}}
+        ],
+        tool_results=[
+            {"tool_name": "write_file", "result": "File created successfully"}
+        ],
+        round_type="implementation",
+        context={"files_implemented": 1},
+        summary="Successfully implemented transformer model",
+    )
+
+    # Test memory optimization logging
+    logger.start_new_round(
+        "memory_optimization", {"trigger_reason": "write_file_detected"}
+    )
+
+    # Mock messages before and after optimization
+    messages_before = [
+        {"role": "user", "content": "Original message 1"},
+        {"role": "assistant", "content": "Original response 1"},
+        {"role": "user", "content": "Original message 2"},
+        {"role": "assistant", "content": "Original response 2"},
+        {"role": "user", "content": "Original message 3"},
+    ]
+
+    messages_after = [
+        {"role": "user", "content": "Original message 1"},
+        {"role": "assistant", "content": "Original response 1"},
+        {"role": "user", "content": "Original message 3"},
+    ]
+
+    # Mock optimization stats
+    optimization_stats = {
+        "implemented_files_tracked": 2,
+        "current_round": 5,
+        "concise_mode_active": True,
+    }
+
+    # Log memory optimization
+    logger.log_memory_optimization(
+        messages_before=messages_before,
+        messages_after=messages_after,
+        optimization_stats=optimization_stats,
+        approach="clear_after_write_file",
+    )
+
+    logger.complete_round("Memory optimization test completed")
+
+    # Finalize session
+    logger.finalize_session(
+        "Test session with memory optimization logging completed successfully"
+    )
+
+    print("✅ Dialogue logger test completed with memory optimization")

projects/ui/DeepCode/utils/file_processor.py

@@ -0,0 +1,438 @@
+"""
+File processing utilities for handling paper files and related operations.
+"""
+
+import json
+import os
+import re
+from typing import Dict, List, Optional, Union
+
+
+class FileProcessor:
+    """
+    A class to handle file processing operations including path extraction and file reading.
+    """
+
+    @staticmethod
+    def extract_file_path(file_info: Union[str, Dict]) -> Optional[str]:
+        """
+        Extract paper directory path from the input information.
+
+        Args:
+            file_info: Either a JSON string or a dictionary containing file information
+
+        Returns:
+            Optional[str]: The extracted paper directory path or None if not found
+        """
+        try:
+            # Handle direct file path input
+            if isinstance(file_info, str):
+                # Check if it's a file path (existing or not)
+                if file_info.endswith(
+                    (".md", ".pdf", ".txt", ".docx", ".doc", ".html", ".htm")
+                ):
+                    # It's a file path, return the directory
+                    return os.path.dirname(os.path.abspath(file_info))
+                elif os.path.exists(file_info):
+                    if os.path.isfile(file_info):
+                        return os.path.dirname(os.path.abspath(file_info))
+                    elif os.path.isdir(file_info):
+                        return os.path.abspath(file_info)
+
+                # Try to parse as JSON
+                try:
+                    info_dict = json.loads(file_info)
+                except json.JSONDecodeError:
+                    # 尝试从文本中提取JSON
+                    info_dict = FileProcessor.extract_json_from_text(file_info)
+                    if not info_dict:
+                        # If not JSON and doesn't look like a file path, raise error
+                        raise ValueError(
+                            f"Input is neither a valid file path nor JSON: {file_info}"
+                        )
+            else:
+                info_dict = file_info
+
+            # Extract paper path from dictionary
+            paper_path = info_dict.get("paper_path")
+            if not paper_path:
+                raise ValueError("No paper_path found in input dictionary")
+
+            # Get the directory path instead of the file path
+            paper_dir = os.path.dirname(paper_path)
+
+            # Convert to absolute path if relative
+            if not os.path.isabs(paper_dir):
+                paper_dir = os.path.abspath(paper_dir)
+
+            return paper_dir
+
+        except (AttributeError, TypeError) as e:
+            raise ValueError(f"Invalid input format: {str(e)}")
+
+    @staticmethod
+    def find_markdown_file(directory: str) -> Optional[str]:
+        """
+        Find the first markdown file in the given directory.
+
+        Args:
+            directory: Directory path to search
+
+        Returns:
+            Optional[str]: Path to the markdown file or None if not found
+        """
+        if not os.path.isdir(directory):
+            return None
+
+        for file in os.listdir(directory):
+            if file.endswith(".md"):
+                return os.path.join(directory, file)
+        return None
+
+    @staticmethod
+    def parse_markdown_sections(content: str) -> List[Dict[str, Union[str, int, List]]]:
+        """
+        Parse markdown content and organize it by sections based on headers.
+
+        Args:
+            content: The markdown content to parse
+
+        Returns:
+            List[Dict]: A list of sections, each containing:
+                - level: The header level (1-6)
+                - title: The section title
+                - content: The section content
+                - subsections: List of subsections
+        """
+        # Split content into lines
+        lines = content.split("\n")
+        sections = []
+        current_section = None
+        current_content = []
+
+        for line in lines:
+            # Check if line is a header
+            header_match = re.match(r"^(#{1,6})\s+(.+)$", line)
+
+            if header_match:
+                # If we were building a section, save its content
+                if current_section is not None:
+                    current_section["content"] = "\n".join(current_content).strip()
+                    sections.append(current_section)
+
+                # Start a new section
+                level = len(header_match.group(1))
+                title = header_match.group(2).strip()
+                current_section = {
+                    "level": level,
+                    "title": title,
+                    "content": "",
+                    "subsections": [],
+                }
+                current_content = []
+            elif current_section is not None:
+                current_content.append(line)
+
+        # Don't forget to save the last section
+        if current_section is not None:
+            current_section["content"] = "\n".join(current_content).strip()
+            sections.append(current_section)
+
+        return FileProcessor._organize_sections(sections)
+
+    @staticmethod
+    def _organize_sections(sections: List[Dict]) -> List[Dict]:
+        """
+        Organize sections into a hierarchical structure based on their levels.
+
+        Args:
+            sections: List of sections with their levels
+
+        Returns:
+            List[Dict]: Organized hierarchical structure of sections
+        """
+        result = []
+        section_stack = []
+
+        for section in sections:
+            while section_stack and section_stack[-1]["level"] >= section["level"]:
+                section_stack.pop()
+
+            if section_stack:
+                section_stack[-1]["subsections"].append(section)
+            else:
+                result.append(section)
+
+            section_stack.append(section)
+
+        return result
+
+    @staticmethod
+    async def read_file_content(file_path: str) -> str:
+        """
+        Read the content of a file asynchronously.
+
+        Args:
+            file_path: Path to the file to read
+
+        Returns:
+            str: The content of the file
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            IOError: If there's an error reading the file
+        """
+        try:
+            # Ensure the file exists
+            if not os.path.exists(file_path):
+                raise FileNotFoundError(f"File not found: {file_path}")
+
+            # Check if file is actually a PDF by reading the first few bytes
+            with open(file_path, "rb") as f:
+                header = f.read(8)
+                if header.startswith(b"%PDF"):
+                    raise IOError(
+                        f"File {file_path} is a PDF file, not a text file. Please convert it to markdown format or use PDF processing tools."
+                    )
+
+            # Read file content
+            # Note: Using async with would be better for large files
+            # but for simplicity and compatibility, using regular file reading
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            return content
+
+        except UnicodeDecodeError as e:
+            raise IOError(
+                f"Error reading file {file_path}: File encoding is not UTF-8. Original error: {str(e)}"
+            )
+        except Exception as e:
+            raise IOError(f"Error reading file {file_path}: {str(e)}")
+
+    @staticmethod
+    def format_section_content(section: Dict) -> str:
+        """
+        Format a section's content with standardized spacing and structure.
+
+        Args:
+            section: Dictionary containing section information
+
+        Returns:
+            str: Formatted section content
+        """
+        # Start with section title
+        formatted = f"\n{'#' * section['level']} {section['title']}\n"
+
+        # Add section content if it exists
+        if section["content"]:
+            formatted += f"\n{section['content'].strip()}\n"
+
+        # Process subsections
+        if section["subsections"]:
+            # Add a separator before subsections if there's content
+            if section["content"]:
+                formatted += "\n---\n"
+
+            # Process each subsection
+            for subsection in section["subsections"]:
+                formatted += FileProcessor.format_section_content(subsection)
+
+        # Add section separator
+        formatted += "\n" + "=" * 80 + "\n"
+
+        return formatted
+
+    @staticmethod
+    def standardize_output(sections: List[Dict]) -> str:
+        """
+        Convert structured sections into a standardized string format.
+
+        Args:
+            sections: List of section dictionaries
+
+        Returns:
+            str: Standardized string output
+        """
+        output = []
+
+        # Process each top-level section
+        for section in sections:
+            output.append(FileProcessor.format_section_content(section))
+
+        # Join all sections with clear separation
+        return "\n".join(output)
+
+    @classmethod
+    async def process_file_input(
+        cls, file_input: Union[str, Dict], base_dir: str = None
+    ) -> Dict:
+        """
+        Process file input information and return the structured content.
+
+        Args:
+            file_input: File input information (JSON string, dict, or direct file path)
+            base_dir: Optional base directory to use for creating paper directories (for sync support)
+
+        Returns:
+            Dict: The structured content with sections and standardized text
+        """
+        try:
+            # 首先尝试从字符串中提取markdown文件路径
+            if isinstance(file_input, str):
+                import re
+
+                file_path_match = re.search(r"`([^`]+\.md)`", file_input)
+                if file_path_match:
+                    paper_path = file_path_match.group(1)
+                    file_input = {"paper_path": paper_path}
+
+            # Extract paper directory path
+            paper_dir = cls.extract_file_path(file_input)
+
+            # If base_dir is provided, adjust paper_dir to be relative to base_dir
+            if base_dir and paper_dir:
+                # If paper_dir is using default location, move it to base_dir
+                if paper_dir.endswith(("deepcode_lab", "agent_folders")):
+                    paper_dir = base_dir
+                else:
+                    # Extract the relative part and combine with base_dir
+                    paper_name = os.path.basename(paper_dir)
+                    # 保持原始目录名不变，不做任何替换
+                    paper_dir = os.path.join(base_dir, "papers", paper_name)
+
+                # Ensure the directory exists
+                os.makedirs(paper_dir, exist_ok=True)
+
+            if not paper_dir:
+                raise ValueError("Could not determine paper directory path")
+
+            # Get the actual file path
+            file_path = None
+            if isinstance(file_input, str):
+                # 尝试解析为JSON（处理下载结果）
+                try:
+                    parsed_json = json.loads(file_input)
+                    if isinstance(parsed_json, dict) and "paper_path" in parsed_json:
+                        file_path = parsed_json.get("paper_path")
+                        # 如果文件不存在，尝试查找markdown文件
+                        if file_path and not os.path.exists(file_path):
+                            paper_dir = os.path.dirname(file_path)
+                            if os.path.isdir(paper_dir):
+                                file_path = cls.find_markdown_file(paper_dir)
+                                if not file_path:
+                                    raise ValueError(
+                                        f"No markdown file found in directory: {paper_dir}"
+                                    )
+                    else:
+                        raise ValueError("Invalid JSON format: missing paper_path")
+                except json.JSONDecodeError:
+                    # 尝试从文本中提取JSON（处理包含额外文本的下载结果）
+                    extracted_json = cls.extract_json_from_text(file_input)
+                    if extracted_json and "paper_path" in extracted_json:
+                        file_path = extracted_json.get("paper_path")
+                        # 如果文件不存在，尝试查找markdown文件
+                        if file_path and not os.path.exists(file_path):
+                            paper_dir = os.path.dirname(file_path)
+                            if os.path.isdir(paper_dir):
+                                file_path = cls.find_markdown_file(paper_dir)
+                                if not file_path:
+                                    raise ValueError(
+                                        f"No markdown file found in directory: {paper_dir}"
+                                    )
+                    else:
+                        # 不是JSON，按文件路径处理
+                        # Check if it's a file path (existing or not)
+                        if file_input.endswith(
+                            (".md", ".pdf", ".txt", ".docx", ".doc", ".html", ".htm")
+                        ):
+                            if os.path.exists(file_input):
+                                file_path = file_input
+                            else:
+                                # File doesn't exist, try to find markdown in the directory
+                                file_path = cls.find_markdown_file(paper_dir)
+                                if not file_path:
+                                    raise ValueError(
+                                        f"No markdown file found in directory: {paper_dir}"
+                                    )
+                        elif os.path.exists(file_input):
+                            if os.path.isfile(file_input):
+                                file_path = file_input
+                            elif os.path.isdir(file_input):
+                                # If it's a directory, find the markdown file
+                                file_path = cls.find_markdown_file(file_input)
+                                if not file_path:
+                                    raise ValueError(
+                                        f"No markdown file found in directory: {file_input}"
+                                    )
+                        else:
+                            raise ValueError(f"Invalid input: {file_input}")
+            else:
+                # Dictionary input
+                file_path = file_input.get("paper_path")
+                # If the file doesn't exist, try to find markdown in the directory
+                if file_path and not os.path.exists(file_path):
+                    paper_dir = os.path.dirname(file_path)
+                    if os.path.isdir(paper_dir):
+                        file_path = cls.find_markdown_file(paper_dir)
+                        if not file_path:
+                            raise ValueError(
+                                f"No markdown file found in directory: {paper_dir}"
+                            )
+
+            if not file_path:
+                raise ValueError("No valid file path found")
+
+            # Read file content
+            content = await cls.read_file_content(file_path)
+
+            # Parse and structure the content
+            structured_content = cls.parse_markdown_sections(content)
+
+            # Generate standardized text output
+            standardized_text = cls.standardize_output(structured_content)
+
+            return {
+                "paper_dir": paper_dir,
+                "file_path": file_path,
+                "sections": structured_content,
+                "standardized_text": standardized_text,
+            }
+
+        except Exception as e:
+            raise ValueError(f"Error processing file input: {str(e)}")
+
+    @staticmethod
+    def extract_json_from_text(text: str) -> Optional[Dict]:
+        """
+        Extract JSON from text that may contain markdown code blocks or other content.
+
+        Args:
+            text: Text that may contain JSON
+
+        Returns:
+            Optional[Dict]: Extracted JSON as dictionary or None if not found
+        """
+        import re
+
+        # Try to find JSON in markdown code blocks
+        json_pattern = r"```json\s*(\{.*?\})\s*```"
+        match = re.search(json_pattern, text, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                pass
+
+        # Try to find standalone JSON
+        json_pattern = r"(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\})"
+        matches = re.findall(json_pattern, text, re.DOTALL)
+        for match in matches:
+            try:
+                parsed = json.loads(match)
+                if isinstance(parsed, dict) and "paper_path" in parsed:
+                    return parsed
+            except json.JSONDecodeError:
+                continue
+
+        return None

projects/ui/DeepCode/utils/llm_utils.py

@@ -0,0 +1,231 @@
+"""
+LLM utility functions for DeepCode project.
+
+This module provides common LLM-related utilities to avoid circular imports
+and reduce code duplication across the project.
+"""
+
+import os
+import yaml
+from typing import Any, Type, Dict, Tuple
+
+# Import LLM classes
+from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
+from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
+
+
+def get_preferred_llm_class(config_path: str = "mcp_agent.secrets.yaml") -> Type[Any]:
+    """
+    Automatically select the LLM class based on API key availability in configuration.
+
+    Reads from YAML config file and returns AnthropicAugmentedLLM if anthropic.api_key
+    is available, otherwise returns OpenAIAugmentedLLM.
+
+    Args:
+        config_path: Path to the YAML configuration file
+
+    Returns:
+        class: The preferred LLM class
+    """
+    try:
+        # Try to read the configuration file
+        if os.path.exists(config_path):
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+
+            # Check for anthropic API key in config
+            anthropic_config = config.get("anthropic", {})
+            anthropic_key = anthropic_config.get("api_key", "")
+
+            if anthropic_key and anthropic_key.strip() and not anthropic_key == "":
+                # print("🤖 Using AnthropicAugmentedLLM (Anthropic API key found in config)")
+                return AnthropicAugmentedLLM
+            else:
+                # print("🤖 Using OpenAIAugmentedLLM (Anthropic API key not configured)")
+                return OpenAIAugmentedLLM
+        else:
+            print(f"🤖 Config file {config_path} not found, using OpenAIAugmentedLLM")
+            return OpenAIAugmentedLLM
+
+    except Exception as e:
+        print(f"🤖 Error reading config file {config_path}: {e}")
+        print("🤖 Falling back to OpenAIAugmentedLLM")
+        return OpenAIAugmentedLLM
+
+
+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)
+
+            # Handle null values in config sections
+            anthropic_config = config.get("anthropic") or {}
+            openai_config = config.get("openai") or {}
+
+            anthropic_model = anthropic_config.get(
+                "default_model", "claude-sonnet-4-20250514"
+            )
+            openai_model = openai_config.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"}
+
+
+def get_document_segmentation_config(
+    config_path: str = "mcp_agent.config.yaml",
+) -> Dict[str, Any]:
+    """
+    Get document segmentation configuration from config file.
+
+    Args:
+        config_path: Path to the main configuration file
+
+    Returns:
+        Dict containing segmentation configuration with default values
+    """
+    try:
+        if os.path.exists(config_path):
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+
+            # Get document segmentation config with defaults
+            seg_config = config.get("document_segmentation", {})
+            return {
+                "enabled": seg_config.get("enabled", True),
+                "size_threshold_chars": seg_config.get("size_threshold_chars", 50000),
+            }
+        else:
+            print(
+                f"📄 Config file {config_path} not found, using default segmentation settings"
+            )
+            return {"enabled": True, "size_threshold_chars": 50000}
+
+    except Exception as e:
+        print(f"📄 Error reading segmentation config from {config_path}: {e}")
+        print("📄 Using default segmentation settings")
+        return {"enabled": True, "size_threshold_chars": 50000}
+
+
+def should_use_document_segmentation(
+    document_content: str, config_path: str = "mcp_agent.config.yaml"
+) -> Tuple[bool, str]:
+    """
+    Determine whether to use document segmentation based on configuration and document size.
+
+    Args:
+        document_content: The content of the document to analyze
+        config_path: Path to the configuration file
+
+    Returns:
+        Tuple of (should_segment, reason) where:
+        - should_segment: Boolean indicating whether to use segmentation
+        - reason: String explaining the decision
+    """
+    seg_config = get_document_segmentation_config(config_path)
+
+    if not seg_config["enabled"]:
+        return False, "Document segmentation disabled in configuration"
+
+    doc_size = len(document_content)
+    threshold = seg_config["size_threshold_chars"]
+
+    if doc_size > threshold:
+        return (
+            True,
+            f"Document size ({doc_size:,} chars) exceeds threshold ({threshold:,} chars)",
+        )
+    else:
+        return (
+            False,
+            f"Document size ({doc_size:,} chars) below threshold ({threshold:,} chars)",
+        )
+
+
+def get_adaptive_agent_config(
+    use_segmentation: bool, search_server_names: list = None
+) -> Dict[str, list]:
+    """
+    Get adaptive agent configuration based on whether to use document segmentation.
+
+    Args:
+        use_segmentation: Whether to include document-segmentation server
+        search_server_names: Base search server names (from get_search_server_names)
+
+    Returns:
+        Dict containing server configurations for different agents
+    """
+    if search_server_names is None:
+        search_server_names = []
+
+    # Base configuration
+    config = {
+        "concept_analysis": [],
+        "algorithm_analysis": search_server_names.copy(),
+        "code_planner": search_server_names.copy(),
+    }
+
+    # Add document-segmentation server if needed
+    if use_segmentation:
+        config["concept_analysis"] = ["document-segmentation"]
+        if "document-segmentation" not in config["algorithm_analysis"]:
+            config["algorithm_analysis"].append("document-segmentation")
+        if "document-segmentation" not in config["code_planner"]:
+            config["code_planner"].append("document-segmentation")
+    else:
+        config["concept_analysis"] = ["filesystem"]
+        if "filesystem" not in config["algorithm_analysis"]:
+            config["algorithm_analysis"].append("filesystem")
+        if "filesystem" not in config["code_planner"]:
+            config["code_planner"].append("filesystem")
+
+    return config
+
+
+def get_adaptive_prompts(use_segmentation: bool) -> Dict[str, str]:
+    """
+    Get appropriate prompt versions based on segmentation usage.
+
+    Args:
+        use_segmentation: Whether to use segmented reading prompts
+
+    Returns:
+        Dict containing prompt configurations
+    """
+    # Import here to avoid circular imports
+    from prompts.code_prompts import (
+        PAPER_CONCEPT_ANALYSIS_PROMPT,
+        PAPER_ALGORITHM_ANALYSIS_PROMPT,
+        CODE_PLANNING_PROMPT,
+        PAPER_CONCEPT_ANALYSIS_PROMPT_TRADITIONAL,
+        PAPER_ALGORITHM_ANALYSIS_PROMPT_TRADITIONAL,
+        CODE_PLANNING_PROMPT_TRADITIONAL,
+    )
+
+    if use_segmentation:
+        return {
+            "concept_analysis": PAPER_CONCEPT_ANALYSIS_PROMPT,
+            "algorithm_analysis": PAPER_ALGORITHM_ANALYSIS_PROMPT,
+            "code_planning": CODE_PLANNING_PROMPT,
+        }
+    else:
+        return {
+            "concept_analysis": PAPER_CONCEPT_ANALYSIS_PROMPT_TRADITIONAL,
+            "algorithm_analysis": PAPER_ALGORITHM_ANALYSIS_PROMPT_TRADITIONAL,
+            "code_planning": CODE_PLANNING_PROMPT_TRADITIONAL,
+        }

projects/ui/DeepCode/utils/simple_llm_logger.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+超简化LLM响应日志记录器
+专注于记录LLM回复的核心内容，配置简单易用
+"""
+
+import json
+import os
+import yaml
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any
+
+
+class SimpleLLMLogger:
+    """超简化的LLM响应日志记录器"""
+
+    def __init__(self, config_path: str = "mcp_agent.config.yaml"):
+        """
+        初始化日志记录器
+
+        Args:
+            config_path: 配置文件路径
+        """
+        self.config = self._load_config(config_path)
+        self.llm_config = self.config.get("llm_logger", {})
+
+        # 如果禁用则直接返回
+        if not self.llm_config.get("enabled", True):
+            self.enabled = False
+            return
+
+        self.enabled = True
+        self._setup_logger()
+
+    def _load_config(self, config_path: str) -> Dict[str, Any]:
+        """加载配置文件"""
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        except Exception as e:
+            print(f"⚠️ 配置文件加载失败: {e}，使用默认配置")
+            return self._get_default_config()
+
+    def _get_default_config(self) -> Dict[str, Any]:
+        """获取默认配置"""
+        return {
+            "llm_logger": {
+                "enabled": True,
+                "output_format": "json",
+                "log_level": "basic",
+                "log_directory": "logs/llm_responses",
+                "filename_pattern": "llm_responses_{timestamp}.jsonl",
+                "include_models": ["claude-sonnet-4", "gpt-4", "o3-mini"],
+                "min_response_length": 50,
+            }
+        }
+
+    def _setup_logger(self):
+        """设置日志记录器"""
+        log_dir = self.llm_config.get("log_directory", "logs/llm_responses")
+
+        # 创建日志目录
+        Path(log_dir).mkdir(parents=True, exist_ok=True)
+
+        # 生成日志文件名
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename_pattern = self.llm_config.get(
+            "filename_pattern", "llm_responses_{timestamp}.jsonl"
+        )
+        self.log_file = os.path.join(
+            log_dir, filename_pattern.format(timestamp=timestamp)
+        )
+
+        print(f"📝 LLM响应日志: {self.log_file}")
+
+    def log_response(self, content: str, model: str = "", agent: str = "", **kwargs):
+        """
+        记录LLM响应 - 简化版本
+
+        Args:
+            content: LLM响应内容
+            model: 模型名称
+            agent: Agent名称
+            **kwargs: 其他可选信息
+        """
+        if not self.enabled:
+            return
+
+        # 检查是否应该记录
+        if not self._should_log(content, model):
+            return
+
+        # 构建日志记录
+        log_entry = self._build_entry(content, model, agent, kwargs)
+
+        # 写入日志
+        self._write_log(log_entry)
+
+        # 控制台显示
+        self._console_log(content, model, agent)
+
+    def _should_log(self, content: str, model: str) -> bool:
+        """检查是否应该记录"""
+        # 检查长度
+        min_length = self.llm_config.get("min_response_length", 50)
+        if len(content) < min_length:
+            return False
+
+        # 检查模型
+        include_models = self.llm_config.get("include_models", [])
+        if include_models and not any(m in model for m in include_models):
+            return False
+
+        return True
+
+    def _build_entry(self, content: str, model: str, agent: str, extra: Dict) -> Dict:
+        """构建日志条目"""
+        log_level = self.llm_config.get("log_level", "basic")
+
+        if log_level == "basic":
+            # 基础级别：只记录核心内容
+            return {
+                "timestamp": datetime.now().isoformat(),
+                "content": content,
+                "model": model,
+            }
+        else:
+            # 详细级别：包含更多信息
+            entry = {
+                "timestamp": datetime.now().isoformat(),
+                "content": content,
+                "model": model,
+                "agent": agent,
+            }
+            # 添加额外信息
+            if "token_usage" in extra:
+                entry["tokens"] = extra["token_usage"]
+            if "session_id" in extra:
+                entry["session"] = extra["session_id"]
+            return entry
+
+    def _write_log(self, entry: Dict):
+        """写入日志文件"""
+        output_format = self.llm_config.get("output_format", "json")
+
+        try:
+            with open(self.log_file, "a", encoding="utf-8") as f:
+                if output_format == "json":
+                    f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+                elif output_format == "text":
+                    timestamp = entry.get("timestamp", "")
+                    model = entry.get("model", "")
+                    content = entry.get("content", "")
+                    f.write(f"[{timestamp}] {model}: {content}\n\n")
+                elif output_format == "markdown":
+                    timestamp = entry.get("timestamp", "")
+                    model = entry.get("model", "")
+                    content = entry.get("content", "")
+                    f.write(f"**{timestamp}** | {model}\n\n{content}\n\n---\n\n")
+        except Exception as e:
+            print(f"⚠️ 写入日志失败: {e}")
+
+    def _console_log(self, content: str, model: str, agent: str):
+        """控制台简要显示"""
+        preview = content[:80] + "..." if len(content) > 80 else content
+        print(f"🤖 {model} ({agent}): {preview}")
+
+
+# 全局实例
+_global_logger = None
+
+
+def get_llm_logger() -> SimpleLLMLogger:
+    """获取全局LLM日志记录器实例"""
+    global _global_logger
+    if _global_logger is None:
+        _global_logger = SimpleLLMLogger()
+    return _global_logger
+
+
+def log_llm_response(content: str, model: str = "", agent: str = "", **kwargs):
+    """便捷函数：记录LLM响应"""
+    logger = get_llm_logger()
+    logger.log_response(content, model, agent, **kwargs)
+
+
+# 示例使用
+if __name__ == "__main__":
+    # 测试日志记录
+    log_llm_response(
+        content="这是一个测试的LLM响应内容，用于验证简化日志记录器的功能是否正常工作。",
+        model="claude-sonnet-4-20250514",
+        agent="TestAgent",
+    )
+
+    print("✅ 简化LLM日志测试完成")

projects/ui/DeepCode/workflows/__init__.py

@@ -0,0 +1,31 @@
+"""
+Intelligent Agent Orchestration Workflows for Research-to-Code Automation.
+
+This package provides advanced AI-driven workflow orchestration capabilities
+for automated research analysis and code implementation synthesis.
+"""
+
+from .agent_orchestration_engine import (
+    run_research_analyzer,
+    run_resource_processor,
+    run_code_analyzer,
+    github_repo_download,
+    paper_reference_analyzer,
+    execute_multi_agent_research_pipeline,
+    paper_code_preparation,  # Deprecated, for backward compatibility
+)
+
+from .code_implementation_workflow import CodeImplementationWorkflow
+
+__all__ = [
+    # Initial workflows
+    "run_research_analyzer",
+    "run_resource_processor",
+    "run_code_analyzer",
+    "github_repo_download",
+    "paper_reference_analyzer",
+    "execute_multi_agent_research_pipeline",  # Main multi-agent pipeline function
+    "paper_code_preparation",  # Deprecated, for backward compatibility
+    # Code implementation workflows
+    "CodeImplementationWorkflow",
+]

projects/ui/DeepCode/workflows/agent_orchestration_engine.py

@@ -0,0 +1,1572 @@
+"""
+Intelligent Agent Orchestration Engine for Research-to-Code Automation
+
+This module serves as the core orchestration engine that coordinates multiple specialized
+AI agents to automate the complete research-to-code transformation pipeline:
+
+1. Research Analysis Agent - Intelligent content processing and extraction
+2. Workspace Infrastructure Agent - Automated environment synthesis
+3. Code Architecture Agent - AI-driven design and planning
+4. Reference Intelligence Agent - Automated knowledge discovery
+5. Repository Acquisition Agent - Intelligent code repository management
+6. Codebase Intelligence Agent - Advanced relationship analysis
+7. Code Implementation Agent - AI-powered code synthesis
+
+Core Features:
+- Multi-agent coordination with intelligent task distribution
+- Local environment automation for seamless deployment
+- Real-time progress monitoring with comprehensive error handling
+- Adaptive workflow optimization based on processing requirements
+- Advanced intelligence analysis with configurable performance modes
+
+Architecture:
+- Async/await based high-performance agent coordination
+- Modular agent design with specialized role separation
+- Intelligent resource management and optimization
+- Comprehensive logging and monitoring infrastructure
+"""
+
+import asyncio
+import json
+import os
+import re
+import yaml
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+# MCP Agent imports
+from mcp_agent.agents.agent import Agent
+from mcp_agent.workflows.llm.augmented_llm import RequestParams
+from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
+
+# Local imports
+from prompts.code_prompts import (
+    PAPER_INPUT_ANALYZER_PROMPT,
+    PAPER_DOWNLOADER_PROMPT,
+    PAPER_REFERENCE_ANALYZER_PROMPT,
+    CHAT_AGENT_PLANNING_PROMPT,
+)
+from utils.file_processor import FileProcessor
+from workflows.code_implementation_workflow import CodeImplementationWorkflow
+from workflows.code_implementation_workflow_index import (
+    CodeImplementationWorkflowWithIndex,
+)
+from utils.llm_utils import (
+    get_preferred_llm_class,
+    should_use_document_segmentation,
+    get_adaptive_agent_config,
+    get_adaptive_prompts,
+)
+from workflows.agents.document_segmentation_agent import prepare_document_segments
+
+# Environment configuration
+os.environ["PYTHONDONTWRITEBYTECODE"] = "1"  # Prevent .pyc file generation
+
+
+def get_default_search_server(config_path: str = "mcp_agent.config.yaml"):
+    """
+    Get the default search server from configuration.
+
+    Args:
+        config_path: Path to the main configuration file
+
+    Returns:
+        str: The default search server name ("brave" or "bocha-mcp")
+    """
+    try:
+        if os.path.exists(config_path):
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+
+            default_server = config.get("default_search_server", "brave")
+            print(f"🔍 Using search server: {default_server}")
+            return default_server
+        else:
+            print(f"⚠️ Config file {config_path} not found, using default: brave")
+            return "brave"
+    except Exception as e:
+        print(f"⚠️ Error reading config file {config_path}: {e}")
+        print("🔍 Falling back to default search server: brave")
+        return "brave"
+
+
+def get_search_server_names(
+    additional_servers: Optional[List[str]] = None,
+) -> List[str]:
+    """
+    Get server names list with the configured default search server.
+
+    Args:
+        additional_servers: Optional list of additional servers to include
+
+    Returns:
+        List[str]: List of server names including the default search server
+    """
+    default_search = get_default_search_server()
+    server_names = [default_search]
+
+    if additional_servers:
+        # Add additional servers, avoiding duplicates
+        for server in additional_servers:
+            if server not in server_names:
+                server_names.append(server)
+
+    return server_names
+
+
+def extract_clean_json(llm_output: str) -> str:
+    """
+    Extract clean JSON from LLM output, removing all extra text and formatting.
+
+    Args:
+        llm_output: Raw LLM output
+
+    Returns:
+        str: Clean JSON string
+    """
+    try:
+        # Try to parse the entire output as JSON first
+        json.loads(llm_output.strip())
+        return llm_output.strip()
+    except json.JSONDecodeError:
+        pass
+
+    # Remove markdown code blocks
+    if "```json" in llm_output:
+        pattern = r"```json\s*(.*?)\s*```"
+        match = re.search(pattern, llm_output, re.DOTALL)
+        if match:
+            json_text = match.group(1).strip()
+            try:
+                json.loads(json_text)
+                return json_text
+            except json.JSONDecodeError:
+                pass
+
+    # Find JSON object starting with {
+    lines = llm_output.split("\n")
+    json_lines = []
+    in_json = False
+    brace_count = 0
+
+    for line in lines:
+        stripped = line.strip()
+        if not in_json and stripped.startswith("{"):
+            in_json = True
+            json_lines = [line]
+            brace_count = stripped.count("{") - stripped.count("}")
+        elif in_json:
+            json_lines.append(line)
+            brace_count += stripped.count("{") - stripped.count("}")
+            if brace_count == 0:
+                break
+
+    if json_lines:
+        json_text = "\n".join(json_lines).strip()
+        try:
+            json.loads(json_text)
+            return json_text
+        except json.JSONDecodeError:
+            pass
+
+    # Last attempt: use regex to find JSON
+    pattern = r"\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}"
+    matches = re.findall(pattern, llm_output, re.DOTALL)
+    for match in matches:
+        try:
+            json.loads(match)
+            return match
+        except json.JSONDecodeError:
+            continue
+
+    # If all methods fail, return original output
+    return llm_output
+
+
+async def run_research_analyzer(prompt_text: str, logger) -> str:
+    """
+    Run the research analysis workflow using ResearchAnalyzerAgent.
+
+    Args:
+        prompt_text: Input prompt text containing research information
+        logger: Logger instance for logging information
+
+    Returns:
+        str: Analysis result from the agent
+    """
+    try:
+        # Log input information for debugging
+        print("📊 Starting research analysis...")
+        print(f"Input prompt length: {len(prompt_text) if prompt_text else 0}")
+        print(f"Input preview: {prompt_text[:200] if prompt_text else 'None'}...")
+
+        if not prompt_text or prompt_text.strip() == "":
+            raise ValueError(
+                "Empty or None prompt_text provided to run_research_analyzer"
+            )
+
+        analyzer_agent = Agent(
+            name="ResearchAnalyzerAgent",
+            instruction=PAPER_INPUT_ANALYZER_PROMPT,
+            server_names=get_search_server_names(),
+        )
+
+        async with analyzer_agent:
+            print("analyzer: Connected to server, calling list_tools...")
+            try:
+                tools = await analyzer_agent.list_tools()
+                print(
+                    "Tools available:",
+                    tools.model_dump() if hasattr(tools, "model_dump") else str(tools),
+                )
+            except Exception as e:
+                print(f"Failed to list tools: {e}")
+
+            try:
+                analyzer = await analyzer_agent.attach_llm(get_preferred_llm_class())
+                print("✅ LLM attached successfully")
+            except Exception as e:
+                print(f"❌ Failed to attach LLM: {e}")
+                raise
+
+            # Set higher token output for research analysis
+            analysis_params = RequestParams(
+                max_tokens=6144,
+                temperature=0.3,
+            )
+
+            print(
+                f"🔄 Making LLM request with params: max_tokens={analysis_params.max_tokens}, temperature={analysis_params.temperature}"
+            )
+
+            try:
+                raw_result = await analyzer.generate_str(
+                    message=prompt_text, request_params=analysis_params
+                )
+
+                print("✅ LLM request completed")
+                print(f"Raw result type: {type(raw_result)}")
+                print(f"Raw result length: {len(raw_result) if raw_result else 0}")
+
+                if not raw_result:
+                    print("❌ CRITICAL: raw_result is empty or None!")
+                    print("This could indicate:")
+                    print("1. LLM API call failed silently")
+                    print("2. API rate limiting or quota exceeded")
+                    print("3. Network connectivity issues")
+                    print("4. MCP server communication problems")
+                    raise ValueError("LLM returned empty result")
+
+            except Exception as e:
+                print(f"❌ LLM generation failed: {e}")
+                print(f"Exception type: {type(e)}")
+                raise
+
+            # Clean LLM output to ensure only pure JSON is returned
+            try:
+                clean_result = extract_clean_json(raw_result)
+                print(f"Raw LLM output: {raw_result}")
+                print(f"Cleaned JSON output: {clean_result}")
+
+                # Log to SimpleLLMLogger
+                if hasattr(logger, "log_response"):
+                    logger.log_response(
+                        clean_result,
+                        model="ResearchAnalyzer",
+                        agent="ResearchAnalyzerAgent",
+                    )
+
+                if not clean_result or clean_result.strip() == "":
+                    print("❌ CRITICAL: clean_result is empty after JSON extraction!")
+                    print(f"Original raw_result was: {raw_result}")
+                    raise ValueError("JSON extraction resulted in empty output")
+
+                return clean_result
+
+            except Exception as e:
+                print(f"❌ JSON extraction failed: {e}")
+                print(f"Raw result was: {raw_result}")
+                raise
+
+    except Exception as e:
+        print(f"❌ run_research_analyzer failed: {e}")
+        print(f"Exception details: {type(e).__name__}: {str(e)}")
+        raise
+
+
+async def run_resource_processor(analysis_result: str, logger) -> str:
+    """
+    Run the resource processing workflow using ResourceProcessorAgent.
+
+    Args:
+        analysis_result: Result from the research analyzer
+        logger: Logger instance for logging information
+
+    Returns:
+        str: Processing result from the agent
+    """
+    processor_agent = Agent(
+        name="ResourceProcessorAgent",
+        instruction=PAPER_DOWNLOADER_PROMPT,
+        server_names=["filesystem", "file-downloader"],
+    )
+
+    async with processor_agent:
+        print("processor: Connected to server, calling list_tools...")
+        tools = await processor_agent.list_tools()
+        print(
+            "Tools available:",
+            tools.model_dump() if hasattr(tools, "model_dump") else str(tools),
+        )
+
+        processor = await processor_agent.attach_llm(get_preferred_llm_class())
+
+        # Set higher token output for resource processing
+        processor_params = RequestParams(
+            max_tokens=4096,
+            temperature=0.2,
+        )
+
+        return await processor.generate_str(
+            message=analysis_result, request_params=processor_params
+        )
+
+
+async def run_code_analyzer(
+    paper_dir: str, logger, use_segmentation: bool = True
+) -> str:
+    """
+    Run the adaptive code analysis workflow using multiple agents for comprehensive code planning.
+
+    This function orchestrates three specialized agents with adaptive configuration:
+    - ConceptAnalysisAgent: Analyzes system architecture and conceptual framework
+    - AlgorithmAnalysisAgent: Extracts algorithms, formulas, and technical details
+    - CodePlannerAgent: Integrates outputs into a comprehensive implementation plan
+
+    Args:
+        paper_dir: Directory path containing the research paper and related resources
+        logger: Logger instance for logging information
+        use_segmentation: Whether to use document segmentation capabilities
+
+    Returns:
+        str: Comprehensive analysis result from the coordinated agents
+    """
+    # Get adaptive configuration based on segmentation usage
+    search_server_names = get_search_server_names()
+    agent_config = get_adaptive_agent_config(use_segmentation, search_server_names)
+    prompts = get_adaptive_prompts(use_segmentation)
+
+    print(
+        f"📊 Code analysis mode: {'Segmented' if use_segmentation else 'Traditional'}"
+    )
+    print(f"   Agent configurations: {agent_config}")
+
+    concept_analysis_agent = Agent(
+        name="ConceptAnalysisAgent",
+        instruction=prompts["concept_analysis"],
+        server_names=agent_config["concept_analysis"],
+    )
+    algorithm_analysis_agent = Agent(
+        name="AlgorithmAnalysisAgent",
+        instruction=prompts["algorithm_analysis"],
+        server_names=agent_config["algorithm_analysis"],
+    )
+    code_planner_agent = Agent(
+        name="CodePlannerAgent",
+        instruction=prompts["code_planning"],
+        server_names=agent_config["code_planner"],
+    )
+
+    code_aggregator_agent = ParallelLLM(
+        fan_in_agent=code_planner_agent,
+        fan_out_agents=[concept_analysis_agent, algorithm_analysis_agent],
+        llm_factory=get_preferred_llm_class(),
+    )
+
+    # Set appropriate token output limit for Claude models (max 8192)
+    enhanced_params = RequestParams(
+        max_tokens=8192,  # Adjusted to Claude 3.5 Sonnet's actual limit
+        temperature=0.3,
+    )
+
+    # Concise message for multi-agent paper analysis and code planning
+    message = f"""Analyze the research paper in directory: {paper_dir}
+
+Please locate and analyze the markdown (.md) file containing the research paper. Based on your analysis, generate a comprehensive code reproduction plan that includes:
+
+1. Complete system architecture and component breakdown
+2. All algorithms, formulas, and implementation details
+3. Detailed file structure and implementation roadmap
+
+The goal is to create a reproduction plan detailed enough for independent implementation."""
+
+    result = await code_aggregator_agent.generate_str(
+        message=message, request_params=enhanced_params
+    )
+    print(f"Code analysis result: {result}")
+    return result
+
+
+async def github_repo_download(search_result: str, paper_dir: str, logger) -> str:
+    """
+    Download GitHub repositories based on search results.
+
+    Args:
+        search_result: Result from GitHub repository search
+        paper_dir: Directory where the paper and its code will be stored
+        logger: Logger instance for logging information
+
+    Returns:
+        str: Download result
+    """
+    github_download_agent = Agent(
+        name="GithubDownloadAgent",
+        instruction="Download github repo to the directory {paper_dir}/code_base".format(
+            paper_dir=paper_dir
+        ),
+        server_names=["filesystem", "github-downloader"],
+    )
+
+    async with github_download_agent:
+        print("GitHub downloader: Downloading repositories...")
+        downloader = await github_download_agent.attach_llm(get_preferred_llm_class())
+
+        # Set higher token output for GitHub download
+        github_params = RequestParams(
+            max_tokens=4096,
+            temperature=0.1,
+        )
+
+        return await downloader.generate_str(
+            message=search_result, request_params=github_params
+        )
+
+
+async def paper_reference_analyzer(paper_dir: str, logger) -> str:
+    """
+    Run the paper reference analysis and GitHub repository workflow.
+
+    Args:
+        analysis_result: Result from the paper analyzer
+        logger: Logger instance for logging information
+
+    Returns:
+        str: Reference analysis result
+    """
+    reference_analysis_agent = Agent(
+        name="ReferenceAnalysisAgent",
+        instruction=PAPER_REFERENCE_ANALYZER_PROMPT,
+        server_names=["filesystem", "fetch"],
+    )
+    message = f"""Analyze the research paper in directory: {paper_dir}
+
+Please locate and analyze the markdown (.md) file containing the research paper. **Focus specifically on the References/Bibliography section** to identify and analyze the 5 most relevant references that have GitHub repositories.
+
+Focus on:
+1. **References section analysis** - Extract all citations from the References/Bibliography part
+2. References with high-quality GitHub implementations
+3. Papers cited for methodology, algorithms, or core techniques
+4. Related work that shares similar technical approaches
+5. Implementation references that could provide code patterns
+
+Goal: Find the most valuable GitHub repositories from the paper's reference list for code implementation reference."""
+
+    async with reference_analysis_agent:
+        print("Reference analyzer: Connected to server, analyzing references...")
+        analyzer = await reference_analysis_agent.attach_llm(get_preferred_llm_class())
+
+        reference_result = await analyzer.generate_str(message=message)
+        return reference_result
+
+
+async def _process_input_source(input_source: str, logger) -> str:
+    """
+    Process and validate input source (file path or URL).
+
+    Args:
+        input_source: Input source (file path or analysis result)
+        logger: Logger instance
+
+    Returns:
+        str: Processed input source
+    """
+    if input_source.startswith("file://"):
+        file_path = input_source[7:]
+        if os.name == "nt" and file_path.startswith("/"):
+            file_path = file_path.lstrip("/")
+        return file_path
+    return input_source
+
+
+async def orchestrate_research_analysis_agent(
+    input_source: str, logger, progress_callback: Optional[Callable] = None
+) -> Tuple[str, str]:
+    """
+    Orchestrate intelligent research analysis and resource processing automation.
+
+    This agent coordinates multiple AI components to analyze research content
+    and process associated resources with automated workflow management.
+
+    Args:
+        input_source: Research input source for analysis
+        logger: Logger instance for process tracking
+        progress_callback: Progress callback function for workflow monitoring
+
+    Returns:
+        tuple: (analysis_result, resource_processing_result)
+    """
+    # Step 1: Research Analysis
+    if progress_callback:
+        progress_callback(
+            10, "📊 Analyzing research content and extracting key information..."
+        )
+    analysis_result = await run_research_analyzer(input_source, logger)
+
+    # Add brief pause for system stability
+    await asyncio.sleep(5)
+
+    # Step 2: Download Processing
+    if progress_callback:
+        progress_callback(
+            25, "📥 Processing downloads and preparing document structure..."
+        )
+    download_result = await run_resource_processor(analysis_result, logger)
+
+    return analysis_result, download_result
+
+
+async def synthesize_workspace_infrastructure_agent(
+    download_result: str, logger, workspace_dir: Optional[str] = None
+) -> Dict[str, str]:
+    """
+    Synthesize intelligent research workspace infrastructure with automated structure generation.
+
+    This agent autonomously creates and configures the optimal workspace architecture
+    for research project implementation with AI-driven path optimization.
+
+    Args:
+        download_result: Resource processing result from analysis agent
+        logger: Logger instance for infrastructure tracking
+        workspace_dir: Optional workspace directory path for environment customization
+
+    Returns:
+        dict: Comprehensive workspace infrastructure metadata
+    """
+    # Parse download result to get file information
+    result = await FileProcessor.process_file_input(
+        download_result, base_dir=workspace_dir
+    )
+    paper_dir = result["paper_dir"]
+
+    # Log workspace infrastructure synthesis
+    print("🏗️ Intelligent workspace infrastructure synthesized:")
+    print(f"   Base workspace environment: {workspace_dir or 'auto-detected'}")
+    print(f"   Research workspace: {paper_dir}")
+    print("   AI-driven path optimization: active")
+
+    return {
+        "paper_dir": paper_dir,
+        "standardized_text": result["standardized_text"],
+        "reference_path": os.path.join(paper_dir, "reference.txt"),
+        "initial_plan_path": os.path.join(paper_dir, "initial_plan.txt"),
+        "download_path": os.path.join(paper_dir, "github_download.txt"),
+        "index_report_path": os.path.join(paper_dir, "codebase_index_report.txt"),
+        "implementation_report_path": os.path.join(
+            paper_dir, "code_implementation_report.txt"
+        ),
+        "workspace_dir": workspace_dir,
+    }
+
+
+async def orchestrate_reference_intelligence_agent(
+    dir_info: Dict[str, str], logger, progress_callback: Optional[Callable] = None
+) -> str:
+    """
+    Orchestrate intelligent reference analysis with automated research discovery.
+
+    This agent autonomously processes research references and discovers
+    related work using advanced AI-powered analysis algorithms.
+
+    Args:
+        dir_info: Workspace infrastructure metadata
+        logger: Logger instance for intelligence tracking
+        progress_callback: Progress callback function for monitoring
+
+    Returns:
+        str: Comprehensive reference intelligence analysis result
+    """
+    if progress_callback:
+        progress_callback(50, "🧠 Orchestrating reference intelligence discovery...")
+
+    reference_path = dir_info["reference_path"]
+
+    # Check if reference analysis already exists
+    if os.path.exists(reference_path):
+        print(f"Found existing reference analysis at {reference_path}")
+        with open(reference_path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    # Execute reference analysis
+    reference_result = await paper_reference_analyzer(dir_info["paper_dir"], logger)
+
+    # Save reference analysis result
+    with open(reference_path, "w", encoding="utf-8") as f:
+        f.write(reference_result)
+    print(f"Reference analysis saved to {reference_path}")
+
+    return reference_result
+
+
+async def orchestrate_document_preprocessing_agent(
+    dir_info: Dict[str, str], logger
+) -> Dict[str, Any]:
+    """
+    Orchestrate adaptive document preprocessing with intelligent segmentation control.
+
+    This agent autonomously determines whether to use document segmentation based on
+    configuration settings and document size, then applies the appropriate processing strategy.
+
+    Args:
+        dir_info: Workspace infrastructure metadata
+        logger: Logger instance for preprocessing tracking
+
+    Returns:
+        dict: Document preprocessing result with segmentation metadata
+    """
+
+    try:
+        print("🔍 Starting adaptive document preprocessing...")
+        print(f"   Paper directory: {dir_info['paper_dir']}")
+
+        # Step 1: Check if any markdown files exist
+        md_files = []
+        try:
+            md_files = [
+                f for f in os.listdir(dir_info["paper_dir"]) if f.endswith(".md")
+            ]
+        except Exception as e:
+            print(f"⚠️ Error reading paper directory: {e}")
+
+        if not md_files:
+            print("ℹ️ No markdown files found - skipping document preprocessing")
+            dir_info["segments_ready"] = False
+            dir_info["use_segmentation"] = False
+            return {
+                "status": "skipped",
+                "reason": "no_markdown_files",
+                "paper_dir": dir_info["paper_dir"],
+                "segments_ready": False,
+                "use_segmentation": False,
+            }
+
+        # Step 2: Read document content to determine size
+        md_path = os.path.join(dir_info["paper_dir"], md_files[0])
+        try:
+            # Check if file is actually a PDF by reading the first few bytes
+            with open(md_path, "rb") as f:
+                header = f.read(8)
+                if header.startswith(b"%PDF"):
+                    raise IOError(
+                        f"File {md_path} is a PDF file, not a text file. Please convert it to markdown format or use PDF processing tools."
+                    )
+
+            with open(md_path, "r", encoding="utf-8") as f:
+                document_content = f.read()
+        except Exception as e:
+            print(f"⚠️ Error reading document content: {e}")
+            dir_info["segments_ready"] = False
+            dir_info["use_segmentation"] = False
+            return {
+                "status": "error",
+                "error_message": f"Failed to read document: {str(e)}",
+                "paper_dir": dir_info["paper_dir"],
+                "segments_ready": False,
+                "use_segmentation": False,
+            }
+
+        # Step 3: Determine if segmentation should be used
+        should_segment, reason = should_use_document_segmentation(document_content)
+        print(f"📊 Segmentation decision: {should_segment}")
+        print(f"   Reason: {reason}")
+
+        # Store decision in dir_info for downstream agents
+        dir_info["use_segmentation"] = should_segment
+
+        if should_segment:
+            print("🔧 Using intelligent document segmentation workflow...")
+
+            # Prepare document segments using the segmentation agent
+            segmentation_result = await prepare_document_segments(
+                paper_dir=dir_info["paper_dir"], logger=logger
+            )
+
+            if segmentation_result["status"] == "success":
+                print("✅ Document segmentation completed successfully!")
+                print(f"   Segments directory: {segmentation_result['segments_dir']}")
+                print("   🧠 Intelligent segments ready for planning agents")
+
+                # Add segment information to dir_info for downstream agents
+                dir_info["segments_dir"] = segmentation_result["segments_dir"]
+                dir_info["segments_ready"] = True
+
+                return segmentation_result
+
+            else:
+                print(
+                    f"⚠️ Document segmentation failed: {segmentation_result.get('error_message', 'Unknown error')}"
+                )
+                print("   Falling back to traditional full-document processing...")
+                dir_info["segments_ready"] = False
+                dir_info["use_segmentation"] = False
+
+                return {
+                    "status": "fallback_to_traditional",
+                    "original_error": segmentation_result.get(
+                        "error_message", "Unknown error"
+                    ),
+                    "paper_dir": dir_info["paper_dir"],
+                    "segments_ready": False,
+                    "use_segmentation": False,
+                    "fallback_reason": "segmentation_failed",
+                }
+        else:
+            print("📖 Using traditional full-document reading workflow...")
+            dir_info["segments_ready"] = False
+
+            return {
+                "status": "traditional",
+                "reason": reason,
+                "paper_dir": dir_info["paper_dir"],
+                "segments_ready": False,
+                "use_segmentation": False,
+                "document_size": len(document_content),
+            }
+
+    except Exception as e:
+        print(f"❌ Error during document preprocessing: {e}")
+        print("   Continuing with traditional full-document processing...")
+
+        # Ensure fallback settings
+        dir_info["segments_ready"] = False
+        dir_info["use_segmentation"] = False
+
+        return {
+            "status": "error",
+            "paper_dir": dir_info["paper_dir"],
+            "segments_ready": False,
+            "use_segmentation": False,
+            "error_message": str(e),
+        }
+
+
+async def orchestrate_code_planning_agent(
+    dir_info: Dict[str, str], logger, progress_callback: Optional[Callable] = None
+):
+    """
+    Orchestrate intelligent code planning with automated design analysis.
+
+    This agent autonomously generates optimal code reproduction plans and implementation
+    strategies using AI-driven code analysis and planning principles.
+
+    Args:
+        dir_info: Workspace infrastructure metadata
+        logger: Logger instance for planning tracking
+        progress_callback: Progress callback function for monitoring
+    """
+    if progress_callback:
+        progress_callback(40, "🏗️ Synthesizing intelligent code architecture...")
+
+    initial_plan_path = dir_info["initial_plan_path"]
+
+    # Check if initial plan already exists
+    if not os.path.exists(initial_plan_path):
+        # Use segmentation setting from preprocessing phase
+        use_segmentation = dir_info.get("use_segmentation", True)
+        print(f"📊 Planning mode: {'Segmented' if use_segmentation else 'Traditional'}")
+
+        initial_plan_result = await run_code_analyzer(
+            dir_info["paper_dir"], logger, use_segmentation=use_segmentation
+        )
+        with open(initial_plan_path, "w", encoding="utf-8") as f:
+            f.write(initial_plan_result)
+        print(f"Initial plan saved to {initial_plan_path}")
+
+
+async def automate_repository_acquisition_agent(
+    reference_result: str,
+    dir_info: Dict[str, str],
+    logger,
+    progress_callback: Optional[Callable] = None,
+):
+    """
+    Automate intelligent repository acquisition with AI-guided selection.
+
+    This agent autonomously identifies, evaluates, and acquires relevant
+    repositories using intelligent filtering and automated download protocols.
+
+    Args:
+        reference_result: Reference intelligence analysis result
+        dir_info: Workspace infrastructure metadata
+        logger: Logger instance for acquisition tracking
+        progress_callback: Progress callback function for monitoring
+    """
+    if progress_callback:
+        progress_callback(60, "🤖 Automating intelligent repository acquisition...")
+
+    await asyncio.sleep(5)  # Brief pause for stability
+
+    try:
+        download_result = await github_repo_download(
+            reference_result, dir_info["paper_dir"], logger
+        )
+
+        # Save download results
+        with open(dir_info["download_path"], "w", encoding="utf-8") as f:
+            f.write(download_result)
+        print(f"GitHub download results saved to {dir_info['download_path']}")
+
+        # Verify if any repositories were actually downloaded
+        code_base_path = os.path.join(dir_info["paper_dir"], "code_base")
+        if os.path.exists(code_base_path):
+            downloaded_repos = [
+                d
+                for d in os.listdir(code_base_path)
+                if os.path.isdir(os.path.join(code_base_path, d))
+                and not d.startswith(".")
+            ]
+
+            if downloaded_repos:
+                print(
+                    f"Successfully downloaded {len(downloaded_repos)} repositories: {downloaded_repos}"
+                )
+            else:
+                print(
+                    "GitHub download phase completed, but no repositories were found in the code_base directory"
+                )
+                print("This might indicate:")
+                print(
+                    "1. No relevant repositories were identified in the reference analysis"
+                )
+                print(
+                    "2. Repository downloads failed due to access permissions or network issues"
+                )
+                print(
+                    "3. The download agent encountered errors during the download process"
+                )
+        else:
+            print(f"Code base directory was not created: {code_base_path}")
+
+    except Exception as e:
+        print(f"Error during GitHub repository download: {e}")
+        # Still save the error information
+        error_message = f"GitHub download failed: {str(e)}"
+        with open(dir_info["download_path"], "w", encoding="utf-8") as f:
+            f.write(error_message)
+        print(f"GitHub download error saved to {dir_info['download_path']}")
+        raise e  # Re-raise to be handled by the main pipeline
+
+
+async def orchestrate_codebase_intelligence_agent(
+    dir_info: Dict[str, str], logger, progress_callback: Optional[Callable] = None
+) -> Dict:
+    """
+    Orchestrate intelligent codebase analysis with automated knowledge extraction.
+
+    This agent autonomously processes and indexes codebases using advanced
+    AI algorithms for intelligent relationship mapping and knowledge synthesis.
+
+    Args:
+        dir_info: Workspace infrastructure metadata
+        logger: Logger instance for intelligence tracking
+        progress_callback: Progress callback function for monitoring
+
+    Returns:
+        dict: Comprehensive codebase intelligence analysis result
+    """
+    if progress_callback:
+        progress_callback(70, "🧮 Orchestrating codebase intelligence analysis...")
+
+    print(
+        "Initiating intelligent codebase analysis with AI-powered relationship mapping..."
+    )
+    await asyncio.sleep(2)  # Brief pause before starting indexing
+
+    # Check if code_base directory exists and has content
+    code_base_path = os.path.join(dir_info["paper_dir"], "code_base")
+    if not os.path.exists(code_base_path):
+        print(f"Code base directory not found: {code_base_path}")
+        return {
+            "status": "skipped",
+            "message": "No code base directory found - skipping indexing",
+        }
+
+    # Check if there are any repositories in the code_base directory
+    try:
+        repo_dirs = [
+            d
+            for d in os.listdir(code_base_path)
+            if os.path.isdir(os.path.join(code_base_path, d)) and not d.startswith(".")
+        ]
+
+        if not repo_dirs:
+            print(f"No repositories found in {code_base_path}")
+            print("This might be because:")
+            print("1. GitHub download phase didn't complete successfully")
+            print("2. No relevant repositories were identified for download")
+            print("3. Repository download failed due to access issues")
+            print("Continuing with code implementation without codebase indexing...")
+
+            # Save a report about the skipped indexing
+            skip_report = {
+                "status": "skipped",
+                "reason": "no_repositories_found",
+                "message": f"No repositories found in {code_base_path}",
+                "suggestions": [
+                    "Check if GitHub download phase completed successfully",
+                    "Verify if relevant repositories were identified in reference analysis",
+                    "Check network connectivity and GitHub access permissions",
+                ],
+            }
+
+            with open(dir_info["index_report_path"], "w", encoding="utf-8") as f:
+                f.write(str(skip_report))
+            print(f"Indexing skip report saved to {dir_info['index_report_path']}")
+
+            return skip_report
+
+    except Exception as e:
+        print(f"Error checking code base directory: {e}")
+        return {
+            "status": "error",
+            "message": f"Error checking code base directory: {str(e)}",
+        }
+
+    try:
+        from workflows.codebase_index_workflow import run_codebase_indexing
+
+        print(f"Found {len(repo_dirs)} repositories to index: {repo_dirs}")
+
+        # Run codebase index workflow
+        index_result = await run_codebase_indexing(
+            paper_dir=dir_info["paper_dir"],
+            initial_plan_path=dir_info["initial_plan_path"],
+            config_path="mcp_agent.secrets.yaml",
+            logger=logger,
+        )
+
+        # Log indexing results
+        if index_result["status"] == "success":
+            print("Code indexing completed successfully!")
+            print(
+                f"Indexed {index_result['statistics']['total_repositories'] if index_result.get('statistics') else len(index_result['output_files'])} repositories"
+            )
+            print(f"Generated {len(index_result['output_files'])} index files")
+
+            # Save indexing results to file
+            with open(dir_info["index_report_path"], "w", encoding="utf-8") as f:
+                f.write(str(index_result))
+            print(f"Indexing report saved to {dir_info['index_report_path']}")
+
+        elif index_result["status"] == "warning":
+            print(f"Code indexing completed with warnings: {index_result['message']}")
+        else:
+            print(f"Code indexing failed: {index_result['message']}")
+
+        return index_result
+
+    except Exception as e:
+        print(f"Error during codebase indexing workflow: {e}")
+        print("Continuing with code implementation despite indexing failure...")
+
+        # Save error report
+        error_report = {
+            "status": "error",
+            "message": str(e),
+            "phase": "codebase_indexing",
+            "recovery_action": "continuing_with_code_implementation",
+        }
+
+        with open(dir_info["index_report_path"], "w", encoding="utf-8") as f:
+            f.write(str(error_report))
+        print(f"Indexing error report saved to {dir_info['index_report_path']}")
+
+        return error_report
+
+
+async def synthesize_code_implementation_agent(
+    dir_info: Dict[str, str],
+    logger,
+    progress_callback: Optional[Callable] = None,
+    enable_indexing: bool = True,
+) -> Dict:
+    """
+    Synthesize intelligent code implementation with automated development.
+
+    This agent autonomously generates high-quality code implementations using
+    AI-powered development strategies and intelligent code synthesis algorithms.
+
+    Args:
+        dir_info: Workspace infrastructure metadata
+        logger: Logger instance for implementation tracking
+        progress_callback: Progress callback function for monitoring
+        enable_indexing: Whether to enable code reference indexing for enhanced implementation
+
+    Returns:
+        dict: Comprehensive code implementation synthesis result
+    """
+    if progress_callback:
+        progress_callback(85, "🔬 Synthesizing intelligent code implementation...")
+
+    print(
+        "Launching intelligent code synthesis with AI-driven implementation strategies..."
+    )
+    await asyncio.sleep(3)  # Brief pause before starting implementation
+
+    try:
+        # Create code implementation workflow instance based on indexing preference
+        if enable_indexing:
+            print(
+                "🔍 Using enhanced code implementation workflow with reference indexing..."
+            )
+            code_workflow = CodeImplementationWorkflowWithIndex()
+        else:
+            print("⚡ Using standard code implementation workflow (fast mode)...")
+            code_workflow = CodeImplementationWorkflow()
+
+        # Check if initial plan file exists
+        if os.path.exists(dir_info["initial_plan_path"]):
+            print(f"Using initial plan from {dir_info['initial_plan_path']}")
+
+            # Run code implementation workflow with pure code mode
+            implementation_result = await code_workflow.run_workflow(
+                plan_file_path=dir_info["initial_plan_path"],
+                target_directory=dir_info["paper_dir"],
+                pure_code_mode=True,  # Focus on code implementation, skip testing
+            )
+
+            # Log implementation results
+            if implementation_result["status"] == "success":
+                print("Code implementation completed successfully!")
+                print(f"Code directory: {implementation_result['code_directory']}")
+
+                # Save implementation results to file
+                with open(
+                    dir_info["implementation_report_path"], "w", encoding="utf-8"
+                ) as f:
+                    f.write(str(implementation_result))
+                print(
+                    f"Implementation report saved to {dir_info['implementation_report_path']}"
+                )
+
+            else:
+                print(
+                    f"Code implementation failed: {implementation_result.get('message', 'Unknown error')}"
+                )
+
+            return implementation_result
+        else:
+            print(
+                f"Initial plan file not found at {dir_info['initial_plan_path']}, skipping code implementation"
+            )
+            return {
+                "status": "warning",
+                "message": "Initial plan not found - code implementation skipped",
+            }
+
+    except Exception as e:
+        print(f"Error during code implementation workflow: {e}")
+        return {"status": "error", "message": str(e)}
+
+
+async def run_chat_planning_agent(user_input: str, logger) -> str:
+    """
+    Run the chat-based planning agent for user-provided coding requirements.
+
+    This agent transforms user's coding description into a comprehensive implementation plan
+    that can be directly used for code generation. It handles both academic and engineering
+    requirements with intelligent context adaptation.
+
+    Args:
+        user_input: User's coding requirements and description
+        logger: Logger instance for logging information
+
+    Returns:
+        str: Comprehensive implementation plan in YAML format
+    """
+    try:
+        print("💬 Starting chat-based planning agent...")
+        print(f"Input length: {len(user_input) if user_input else 0}")
+        print(f"Input preview: {user_input[:200] if user_input else 'None'}...")
+
+        if not user_input or user_input.strip() == "":
+            raise ValueError(
+                "Empty or None user_input provided to run_chat_planning_agent"
+            )
+
+        # Create the chat planning agent
+        chat_planning_agent = Agent(
+            name="ChatPlanningAgent",
+            instruction=CHAT_AGENT_PLANNING_PROMPT,
+            server_names=get_search_server_names(),  # Dynamic search server configuration
+        )
+
+        async with chat_planning_agent:
+            print("chat_planning: Connected to server, calling list_tools...")
+            try:
+                tools = await chat_planning_agent.list_tools()
+                print(
+                    "Tools available:",
+                    tools.model_dump() if hasattr(tools, "model_dump") else str(tools),
+                )
+            except Exception as e:
+                print(f"Failed to list tools: {e}")
+
+            try:
+                planner = await chat_planning_agent.attach_llm(
+                    get_preferred_llm_class()
+                )
+                print("✅ LLM attached successfully")
+            except Exception as e:
+                print(f"❌ Failed to attach LLM: {e}")
+                raise
+
+            # Set higher token output for comprehensive planning
+            planning_params = RequestParams(
+                max_tokens=8192,  # Higher token limit for detailed plans
+                temperature=0.2,  # Lower temperature for more structured output
+            )
+
+            print(
+                f"🔄 Making LLM request with params: max_tokens={planning_params.max_tokens}, temperature={planning_params.temperature}"
+            )
+
+            # Format the input message for the agent
+            formatted_message = f"""Please analyze the following coding requirements and generate a comprehensive implementation plan:
+
+User Requirements:
+{user_input}
+
+Please provide a detailed implementation plan that covers all aspects needed for successful development."""
+
+            try:
+                raw_result = await planner.generate_str(
+                    message=formatted_message, request_params=planning_params
+                )
+
+                print("✅ Planning request completed")
+                print(f"Raw result type: {type(raw_result)}")
+                print(f"Raw result length: {len(raw_result) if raw_result else 0}")
+
+                if not raw_result:
+                    print("❌ CRITICAL: raw_result is empty or None!")
+                    raise ValueError("Chat planning agent returned empty result")
+
+            except Exception as e:
+                print(f"❌ Planning generation failed: {e}")
+                print(f"Exception type: {type(e)}")
+                raise
+
+            # Log to SimpleLLMLogger
+            if hasattr(logger, "log_response"):
+                logger.log_response(
+                    raw_result, model="ChatPlanningAgent", agent="ChatPlanningAgent"
+                )
+
+            if not raw_result or raw_result.strip() == "":
+                print("❌ CRITICAL: Planning result is empty!")
+                raise ValueError("Chat planning agent produced empty output")
+
+            print("🎯 Chat planning completed successfully")
+            print(f"Planning result preview: {raw_result[:500]}...")
+
+            return raw_result
+
+    except Exception as e:
+        print(f"❌ run_chat_planning_agent failed: {e}")
+        print(f"Exception details: {type(e).__name__}: {str(e)}")
+        raise
+
+
+async def execute_multi_agent_research_pipeline(
+    input_source: str,
+    logger,
+    progress_callback: Optional[Callable] = None,
+    enable_indexing: bool = True,
+) -> str:
+    """
+    Execute the complete intelligent multi-agent research orchestration pipeline.
+
+    This is the main AI orchestration engine that coordinates autonomous research workflow agents:
+    - Local workspace automation for seamless environment management
+    - Intelligent research analysis with automated content processing
+    - AI-driven code architecture synthesis and design automation
+    - Reference intelligence discovery with automated knowledge extraction (optional)
+    - Codebase intelligence orchestration with automated relationship analysis (optional)
+    - Intelligent code implementation synthesis with AI-powered development
+
+    Args:
+        input_source: Research input source (file path, URL, or preprocessed analysis)
+        logger: Logger instance for comprehensive workflow intelligence tracking
+        progress_callback: Progress callback function for real-time monitoring
+        enable_indexing: Whether to enable advanced intelligence analysis (default: True)
+
+    Returns:
+        str: The comprehensive pipeline execution result with status and outcomes
+    """
+    try:
+        # Phase 0: Workspace Setup
+        if progress_callback:
+            progress_callback(5, "🔄 Setting up workspace for file processing...")
+
+        print("🚀 Initializing intelligent multi-agent research orchestration system")
+
+        # Setup local workspace directory
+        workspace_dir = os.path.join(os.getcwd(), "deepcode_lab")
+        os.makedirs(workspace_dir, exist_ok=True)
+
+        print("📁 Working environment: local")
+        print(f"📂 Workspace directory: {workspace_dir}")
+        print("✅ Workspace status: ready")
+
+        # Log intelligence functionality status
+        if enable_indexing:
+            print("🧠 Advanced intelligence analysis enabled - comprehensive workflow")
+        else:
+            print("⚡ Optimized mode - advanced intelligence analysis disabled")
+
+        # Phase 1: Input Processing and Validation
+        input_source = await _process_input_source(input_source, logger)
+
+        # Phase 2: Research Analysis and Resource Processing (if needed)
+        if isinstance(input_source, str) and (
+            input_source.endswith((".pdf", ".docx", ".txt", ".html", ".md"))
+            or input_source.startswith(("http", "file://"))
+        ):
+            (
+                analysis_result,
+                download_result,
+            ) = await orchestrate_research_analysis_agent(
+                input_source, logger, progress_callback
+            )
+        else:
+            download_result = input_source  # Use input directly if already processed
+
+        # Phase 3: Workspace Infrastructure Synthesis
+        if progress_callback:
+            progress_callback(
+                40, "🏗️ Synthesizing intelligent workspace infrastructure..."
+            )
+
+        dir_info = await synthesize_workspace_infrastructure_agent(
+            download_result, logger, workspace_dir
+        )
+        await asyncio.sleep(30)
+
+        # Phase 3.5: Document Segmentation and Preprocessing
+
+        segmentation_result = await orchestrate_document_preprocessing_agent(
+            dir_info, logger
+        )
+
+        # Handle segmentation result
+        if segmentation_result["status"] == "success":
+            print("✅ Document preprocessing completed successfully!")
+            print(
+                f"   📊 Using segmentation: {dir_info.get('use_segmentation', False)}"
+            )
+            if dir_info.get("segments_ready", False):
+                print(
+                    f"   📁 Segments directory: {segmentation_result.get('segments_dir', 'N/A')}"
+                )
+        elif segmentation_result["status"] == "fallback_to_traditional":
+            print("⚠️ Document segmentation failed, using traditional processing")
+            print(
+                f"   Original error: {segmentation_result.get('original_error', 'Unknown')}"
+            )
+        else:
+            print(
+                f"⚠️ Document preprocessing encountered issues: {segmentation_result.get('error_message', 'Unknown')}"
+            )
+
+        # Phase 4: Code Planning Orchestration
+        await orchestrate_code_planning_agent(dir_info, logger, progress_callback)
+
+        # Phase 5: Reference Intelligence (only when indexing is enabled)
+        if enable_indexing:
+            reference_result = await orchestrate_reference_intelligence_agent(
+                dir_info, logger, progress_callback
+            )
+        else:
+            print("🔶 Skipping reference intelligence analysis (fast mode enabled)")
+            # Create empty reference analysis result to maintain file structure consistency
+            reference_result = "Reference intelligence analysis skipped - fast mode enabled for optimized processing"
+            with open(dir_info["reference_path"], "w", encoding="utf-8") as f:
+                f.write(reference_result)
+
+        # Phase 6: Repository Acquisition Automation (optional)
+        if enable_indexing:
+            await automate_repository_acquisition_agent(
+                reference_result, dir_info, logger, progress_callback
+            )
+        else:
+            print("🔶 Skipping automated repository acquisition (fast mode enabled)")
+            # Create empty download result file to maintain file structure consistency
+            with open(dir_info["download_path"], "w", encoding="utf-8") as f:
+                f.write(
+                    "Automated repository acquisition skipped - fast mode enabled for optimized processing"
+                )
+
+        # Phase 7: Codebase Intelligence Orchestration (optional)
+        if enable_indexing:
+            index_result = await orchestrate_codebase_intelligence_agent(
+                dir_info, logger, progress_callback
+            )
+        else:
+            print("🔶 Skipping codebase intelligence orchestration (fast mode enabled)")
+            # Create a skipped indexing result
+            index_result = {
+                "status": "skipped",
+                "reason": "fast_mode_enabled",
+                "message": "Codebase intelligence orchestration skipped for optimized processing",
+            }
+            with open(dir_info["index_report_path"], "w", encoding="utf-8") as f:
+                f.write(str(index_result))
+
+        # Phase 8: Code Implementation Synthesis
+        implementation_result = await synthesize_code_implementation_agent(
+            dir_info, logger, progress_callback, enable_indexing
+        )
+
+        # Final Status Report
+        if enable_indexing:
+            pipeline_summary = (
+                f"Multi-agent research pipeline completed for {dir_info['paper_dir']}"
+            )
+        else:
+            pipeline_summary = f"Multi-agent research pipeline completed (fast mode) for {dir_info['paper_dir']}"
+
+        # Add indexing status to summary
+        if not enable_indexing:
+            pipeline_summary += (
+                "\n⚡ Fast mode: GitHub download and codebase indexing skipped"
+            )
+        elif index_result["status"] == "skipped":
+            pipeline_summary += f"\n🔶 Codebase indexing: {index_result['message']}"
+        elif index_result["status"] == "error":
+            pipeline_summary += (
+                f"\n❌ Codebase indexing failed: {index_result['message']}"
+            )
+        elif index_result["status"] == "success":
+            pipeline_summary += "\n✅ Codebase indexing completed successfully"
+
+        # Add implementation status to summary
+        if implementation_result["status"] == "success":
+            pipeline_summary += "\n🎉 Code implementation completed successfully!"
+            pipeline_summary += (
+                f"\n📁 Code generated in: {implementation_result['code_directory']}"
+            )
+            return pipeline_summary
+        elif implementation_result["status"] == "warning":
+            pipeline_summary += (
+                f"\n⚠️ Code implementation: {implementation_result['message']}"
+            )
+            return pipeline_summary
+        else:
+            pipeline_summary += (
+                f"\n❌ Code implementation failed: {implementation_result['message']}"
+            )
+            return pipeline_summary
+
+    except Exception as e:
+        print(f"Error in execute_multi_agent_research_pipeline: {e}")
+        raise e
+
+
+# Backward compatibility alias (deprecated)
+async def paper_code_preparation(
+    input_source: str, logger, progress_callback: Optional[Callable] = None
+) -> str:
+    """
+    Deprecated: Use execute_multi_agent_research_pipeline instead.
+
+    Args:
+        input_source: Input source
+        logger: Logger instance
+        progress_callback: Progress callback function
+
+    Returns:
+        str: Pipeline result
+    """
+    print(
+        "paper_code_preparation is deprecated. Use execute_multi_agent_research_pipeline instead."
+    )
+    return await execute_multi_agent_research_pipeline(
+        input_source, logger, progress_callback
+    )
+
+
+async def execute_chat_based_planning_pipeline(
+    user_input: str,
+    logger,
+    progress_callback: Optional[Callable] = None,
+    enable_indexing: bool = True,
+) -> str:
+    """
+    Execute the chat-based planning and implementation pipeline.
+
+    This pipeline is designed for users who provide coding requirements directly through chat,
+    bypassing the traditional paper analysis phases (Phase 0-7) and jumping directly to
+    planning and code implementation.
+
+    Pipeline Flow:
+    - Chat Planning: Transform user input into implementation plan
+    - Workspace Setup: Create necessary directory structure
+    - Code Implementation: Generate code based on the plan
+
+    Args:
+        user_input: User's coding requirements and description
+        logger: Logger instance for comprehensive workflow tracking
+        progress_callback: Progress callback function for real-time monitoring
+        enable_indexing: Whether to enable code reference indexing for enhanced implementation
+
+    Returns:
+        str: The pipeline execution result with status and outcomes
+    """
+    try:
+        print("🚀 Initializing chat-based planning and implementation pipeline")
+        print("💬 Chat mode: Direct user requirements to code implementation")
+
+        # Phase 0: Workspace Setup
+        if progress_callback:
+            progress_callback(5, "🔄 Setting up workspace for file processing...")
+
+        # Setup local workspace directory
+        workspace_dir = os.path.join(os.getcwd(), "deepcode_lab")
+        os.makedirs(workspace_dir, exist_ok=True)
+
+        print("📁 Working environment: local")
+        print(f"📂 Workspace directory: {workspace_dir}")
+        print("✅ Workspace status: ready")
+
+        # Phase 1: Chat-Based Planning
+        if progress_callback:
+            progress_callback(
+                30,
+                "💬 Generating comprehensive implementation plan from user requirements...",
+            )
+
+        print("🧠 Running chat-based planning agent...")
+        planning_result = await run_chat_planning_agent(user_input, logger)
+
+        # Phase 2: Workspace Infrastructure Synthesis
+        if progress_callback:
+            progress_callback(
+                50, "🏗️ Synthesizing intelligent workspace infrastructure..."
+            )
+
+        # Create workspace directory structure for chat mode
+        # First, let's create a temporary directory structure that mimics a paper workspace
+        import time
+
+        # Generate a unique paper directory name
+        timestamp = str(int(time.time()))
+        paper_name = f"chat_project_{timestamp}"
+
+        # Use workspace directory
+        chat_paper_dir = os.path.join(workspace_dir, "papers", paper_name)
+
+        os.makedirs(chat_paper_dir, exist_ok=True)
+
+        # Create a synthetic markdown file with user requirements
+        markdown_content = f"""# User Coding Requirements
+
+## Project Description
+This is a coding project generated from user requirements via chat interface.
+
+## User Requirements
+{user_input}
+
+## Generated Implementation Plan
+The following implementation plan was generated by the AI chat planning agent:
+
+```yaml
+{planning_result}
+```
+
+## Project Metadata
+- **Input Type**: Chat Input
+- **Generation Method**: AI Chat Planning Agent
+- **Timestamp**: {timestamp}
+"""
+
+        # Save the markdown file
+        markdown_file_path = os.path.join(chat_paper_dir, f"{paper_name}.md")
+        with open(markdown_file_path, "w", encoding="utf-8") as f:
+            f.write(markdown_content)
+
+        print(f"💾 Created chat project workspace: {chat_paper_dir}")
+        print(f"📄 Saved requirements to: {markdown_file_path}")
+
+        # Create a download result that matches FileProcessor expectations
+        synthetic_download_result = json.dumps(
+            {
+                "status": "success",
+                "paper_path": markdown_file_path,
+                "input_type": "chat_input",
+                "paper_info": {
+                    "title": "User-Provided Coding Requirements",
+                    "source": "chat_input",
+                    "description": "Implementation plan generated from user requirements",
+                },
+            }
+        )
+
+        dir_info = await synthesize_workspace_infrastructure_agent(
+            synthetic_download_result, logger, workspace_dir
+        )
+        await asyncio.sleep(10)  # Brief pause for file system operations
+
+        # Phase 3: Save Planning Result
+        if progress_callback:
+            progress_callback(70, "📝 Saving implementation plan...")
+
+        # Save the planning result to the initial_plan.txt file (same location as Phase 4 in original pipeline)
+        initial_plan_path = dir_info["initial_plan_path"]
+        with open(initial_plan_path, "w", encoding="utf-8") as f:
+            f.write(planning_result)
+        print(f"💾 Implementation plan saved to {initial_plan_path}")
+
+        # Phase 4: Code Implementation Synthesis (same as Phase 8 in original pipeline)
+        if progress_callback:
+            progress_callback(85, "🔬 Synthesizing intelligent code implementation...")
+
+        implementation_result = await synthesize_code_implementation_agent(
+            dir_info, logger, progress_callback, enable_indexing
+        )
+
+        # Final Status Report
+        pipeline_summary = f"Chat-based planning and implementation pipeline completed for {dir_info['paper_dir']}"
+
+        # Add implementation status to summary
+        if implementation_result["status"] == "success":
+            pipeline_summary += "\n🎉 Code implementation completed successfully!"
+            pipeline_summary += (
+                f"\n📁 Code generated in: {implementation_result['code_directory']}"
+            )
+            pipeline_summary += (
+                "\n💬 Generated from user requirements via chat interface"
+            )
+            return pipeline_summary
+        elif implementation_result["status"] == "warning":
+            pipeline_summary += (
+                f"\n⚠️ Code implementation: {implementation_result['message']}"
+            )
+            return pipeline_summary
+        else:
+            pipeline_summary += (
+                f"\n❌ Code implementation failed: {implementation_result['message']}"
+            )
+            return pipeline_summary
+
+    except Exception as e:
+        print(f"Error in execute_chat_based_planning_pipeline: {e}")
+        raise e

projects/ui/DeepCode/workflows/code_implementation_workflow.py

@@ -0,0 +1,993 @@
+"""
+Paper Code Implementation Workflow - MCP-compliant Iterative Development
+
+Features:
+1. File Tree Creation
+2. Code Implementation - Based on aisi-basic-agent iterative development
+
+MCP Architecture:
+- MCP Server: tools/code_implementation_server.py
+- MCP Client: Called through mcp_agent framework
+- Configuration: mcp_agent.config.yaml
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import time
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+
+# MCP Agent imports
+from mcp_agent.agents.agent import Agent
+
+# Local imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from prompts.code_prompts import STRUCTURE_GENERATOR_PROMPT
+from prompts.code_prompts import (
+    GENERAL_CODE_IMPLEMENTATION_SYSTEM_PROMPT,
+)
+from workflows.agents import CodeImplementationAgent
+from workflows.agents.memory_agent_concise import ConciseMemoryAgent
+from config.mcp_tool_definitions import get_mcp_tools
+from utils.llm_utils import get_preferred_llm_class, get_default_models
+# DialogueLogger removed - no longer needed
+
+
+class CodeImplementationWorkflow:
+    """
+    Paper Code Implementation Workflow Manager
+
+    Uses standard MCP architecture:
+    1. Connect to code-implementation server via MCP client
+    2. Use MCP protocol for tool calls
+    3. Support workspace management and operation history tracking
+    """
+
+    # ==================== 1. Class Initialization and Configuration (Infrastructure Layer) ====================
+
+    def __init__(self, config_path: str = "mcp_agent.secrets.yaml"):
+        """Initialize workflow with configuration"""
+        self.config_path = config_path
+        self.api_config = self._load_api_config()
+        self.default_models = get_default_models("mcp_agent.config.yaml")
+        self.logger = self._create_logger()
+        self.mcp_agent = None
+        self.enable_read_tools = (
+            True  # Default value, will be overridden by run_workflow parameter
+        )
+
+    def _load_api_config(self) -> Dict[str, Any]:
+        """Load API configuration from YAML file"""
+        try:
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        except Exception as e:
+            raise Exception(f"Failed to load API config: {e}")
+
+    def _create_logger(self) -> logging.Logger:
+        """Create and configure logger"""
+        logger = logging.getLogger(__name__)
+        # Don't add handlers to child loggers - let them propagate to root
+        logger.setLevel(logging.INFO)
+        return logger
+
+    def _read_plan_file(self, plan_file_path: str) -> str:
+        """Read implementation plan file"""
+        plan_path = Path(plan_file_path)
+        if not plan_path.exists():
+            raise FileNotFoundError(
+                f"Implementation plan file not found: {plan_file_path}"
+            )
+
+        with open(plan_path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    def _check_file_tree_exists(self, target_directory: str) -> bool:
+        """Check if file tree structure already exists"""
+        code_directory = os.path.join(target_directory, "generate_code")
+        return os.path.exists(code_directory) and len(os.listdir(code_directory)) > 0
+
+    # ==================== 2. Public Interface Methods (External API Layer) ====================
+
+    async def run_workflow(
+        self,
+        plan_file_path: str,
+        target_directory: Optional[str] = None,
+        pure_code_mode: bool = False,
+        enable_read_tools: bool = True,
+    ):
+        """Run complete workflow - Main public interface"""
+        # Set the read tools configuration
+        self.enable_read_tools = enable_read_tools
+
+        try:
+            plan_content = self._read_plan_file(plan_file_path)
+
+            if target_directory is None:
+                target_directory = str(Path(plan_file_path).parent)
+
+            # Calculate code directory for workspace alignment
+            code_directory = os.path.join(target_directory, "generate_code")
+
+            self.logger.info("=" * 80)
+            self.logger.info("🚀 STARTING CODE IMPLEMENTATION WORKFLOW")
+            self.logger.info("=" * 80)
+            self.logger.info(f"📄 Plan file: {plan_file_path}")
+            self.logger.info(f"📂 Plan file parent: {target_directory}")
+            self.logger.info(f"🎯 Code directory (MCP workspace): {code_directory}")
+            self.logger.info(
+                f"⚙️  Read tools: {'ENABLED' if self.enable_read_tools else 'DISABLED'}"
+            )
+            self.logger.info("=" * 80)
+
+            results = {}
+
+            # Check if file tree exists
+            if self._check_file_tree_exists(target_directory):
+                self.logger.info("File tree exists, skipping creation")
+                results["file_tree"] = "Already exists, skipped creation"
+            else:
+                self.logger.info("Creating file tree...")
+                results["file_tree"] = await self.create_file_structure(
+                    plan_content, target_directory
+                )
+
+            # Code implementation
+            if pure_code_mode:
+                self.logger.info("Starting pure code implementation...")
+                results["code_implementation"] = await self.implement_code_pure(
+                    plan_content, target_directory, code_directory
+                )
+            else:
+                pass
+
+            self.logger.info("Workflow execution successful")
+
+            return {
+                "status": "success",
+                "plan_file": plan_file_path,
+                "target_directory": target_directory,
+                "code_directory": os.path.join(target_directory, "generate_code"),
+                "results": results,
+                "mcp_architecture": "standard",
+            }
+
+        except Exception as e:
+            self.logger.error(f"Workflow execution failed: {e}")
+
+            return {"status": "error", "message": str(e), "plan_file": plan_file_path}
+        finally:
+            await self._cleanup_mcp_agent()
+
+    async def create_file_structure(
+        self, plan_content: str, target_directory: str
+    ) -> str:
+        """Create file tree structure based on implementation plan"""
+        self.logger.info("Starting file tree creation...")
+
+        structure_agent = Agent(
+            name="StructureGeneratorAgent",
+            instruction=STRUCTURE_GENERATOR_PROMPT,
+            server_names=["command-executor"],
+        )
+
+        async with structure_agent:
+            creator = await structure_agent.attach_llm(
+                get_preferred_llm_class(self.config_path)
+            )
+
+            message = f"""Analyze the following implementation plan and generate shell commands to create the file tree structure.
+
+Target Directory: {target_directory}/generate_code
+
+Implementation Plan:
+{plan_content}
+
+Tasks:
+1. Find the file tree structure in the implementation plan
+2. Generate shell commands (mkdir -p, touch) to create that structure
+3. Use the execute_commands tool to run the commands and create the file structure
+
+Requirements:
+- Use mkdir -p to create directories
+- Use touch to create files
+- Include __init__.py file for Python packages
+- Use relative paths to the target directory
+- Execute commands to actually create the file structure"""
+
+            result = await creator.generate_str(message=message)
+            self.logger.info("File tree structure creation completed")
+            return result
+
+    async def implement_code_pure(
+        self, plan_content: str, target_directory: str, code_directory: str = None
+    ) -> str:
+        """Pure code implementation - focus on code writing without testing"""
+        self.logger.info("Starting pure code implementation (no testing)...")
+
+        # Use provided code_directory or calculate it (for backwards compatibility)
+        if code_directory is None:
+            code_directory = os.path.join(target_directory, "generate_code")
+
+        self.logger.info(f"🎯 Using code directory (MCP workspace): {code_directory}")
+
+        if not os.path.exists(code_directory):
+            raise FileNotFoundError(
+                "File tree structure not found, please run file tree creation first"
+            )
+
+        try:
+            client, client_type = await self._initialize_llm_client()
+            await self._initialize_mcp_agent(code_directory)
+
+            tools = self._prepare_mcp_tool_definitions()
+            system_message = GENERAL_CODE_IMPLEMENTATION_SYSTEM_PROMPT
+            messages = []
+
+            #             implementation_message = f"""**TASK: Implement Research Paper Reproduction Code**
+
+            # You are implementing a complete, working codebase that reproduces the core algorithms, experiments, and methods described in a research paper. Your goal is to create functional code that can replicate the paper's key results and contributions.
+
+            # **What you need to do:**
+            # - Analyze the paper content and reproduction plan to understand requirements
+            # - Implement all core algorithms mentioned in the main body of the paper
+            # - Create the necessary components following the planned architecture
+            # - Test each component to ensure functionality
+            # - Integrate components into a cohesive, executable system
+            # - Focus on reproducing main contributions rather than appendix-only experiments
+
+            # **RESOURCES:**
+            # - **Paper & Reproduction Plan**: `{target_directory}/` (contains .md paper files and initial_plan.txt with detailed implementation guidance)
+            # - **Reference Code Indexes**: `{target_directory}/indexes/` (JSON files with implementation patterns from related codebases)
+            # - **Implementation Directory**: `{code_directory}/` (your working directory for all code files)
+
+            # **CURRENT OBJECTIVE:**
+            # Start by reading the reproduction plan (`{target_directory}/initial_plan.txt`) to understand the implementation strategy, then examine the paper content to identify the first priority component to implement. Use the search_code tool to find relevant reference implementations from the indexes directory (`{target_directory}/indexes/*.json`) before coding.
+
+            # ---
+            # **START:** Review the plan above and begin implementation."""
+            implementation_message = f"""**Task: Implement code based on the following reproduction plan**
+
+**Code Reproduction Plan:**
+{plan_content}
+
+**Working Directory:** {code_directory}
+
+**Current Objective:** Begin implementation by analyzing the plan structure, examining the current project layout, and implementing the first foundation file according to the plan's priority order."""
+
+            messages.append({"role": "user", "content": implementation_message})
+
+            result = await self._pure_code_implementation_loop(
+                client,
+                client_type,
+                system_message,
+                messages,
+                tools,
+                plan_content,
+                target_directory,
+            )
+
+            return result
+
+        finally:
+            await self._cleanup_mcp_agent()
+
+    # ==================== 3. Core Business Logic (Implementation Layer) ====================
+
+    async def _pure_code_implementation_loop(
+        self,
+        client,
+        client_type,
+        system_message,
+        messages,
+        tools,
+        plan_content,
+        target_directory,
+    ):
+        """Pure code implementation loop with memory optimization and phase consistency"""
+        max_iterations = 500
+        iteration = 0
+        start_time = time.time()
+        max_time = 2400  # 40 minutes
+
+        # Initialize specialized agents
+        code_agent = CodeImplementationAgent(
+            self.mcp_agent, self.logger, self.enable_read_tools
+        )
+        memory_agent = ConciseMemoryAgent(plan_content, self.logger, target_directory)
+
+        # Log read tools configuration
+        read_tools_status = "ENABLED" if self.enable_read_tools else "DISABLED"
+        self.logger.info(
+            f"🔧 Read tools (read_file, read_code_mem): {read_tools_status}"
+        )
+        if not self.enable_read_tools:
+            self.logger.info(
+                "🚫 No read mode: read_file and read_code_mem tools will be skipped"
+            )
+
+        # Connect code agent with memory agent for summary generation
+        # Note: Concise memory agent doesn't need LLM client for summary generation
+        code_agent.set_memory_agent(memory_agent, client, client_type)
+
+        # Initialize memory agent with iteration 0
+        memory_agent.start_new_round(iteration=0)
+
+        while iteration < max_iterations:
+            iteration += 1
+            elapsed_time = time.time() - start_time
+
+            if elapsed_time > max_time:
+                self.logger.warning(f"Time limit reached: {elapsed_time:.2f}s")
+                break
+
+            # # Test simplified memory approach if we have files implemented
+            # if iteration == 5 and code_agent.get_files_implemented_count() > 0:
+            #     self.logger.info("🧪 Testing simplified memory approach...")
+            #     test_results = await memory_agent.test_simplified_memory_approach()
+            #     self.logger.info(f"Memory test results: {test_results}")
+
+            # self.logger.info(f"Pure code implementation iteration {iteration}: generating code")
+
+            messages = self._validate_messages(messages)
+            current_system_message = code_agent.get_system_prompt()
+
+            # Round logging removed
+
+            # Call LLM
+            response = await self._call_llm_with_tools(
+                client, client_type, current_system_message, messages, tools
+            )
+
+            response_content = response.get("content", "").strip()
+            if not response_content:
+                response_content = "Continue implementing code files..."
+
+            messages.append({"role": "assistant", "content": response_content})
+
+            # Handle tool calls
+            if response.get("tool_calls"):
+                tool_results = await code_agent.execute_tool_calls(
+                    response["tool_calls"]
+                )
+
+                # Record essential tool results in concise memory agent
+                for tool_call, tool_result in zip(response["tool_calls"], tool_results):
+                    memory_agent.record_tool_result(
+                        tool_name=tool_call["name"],
+                        tool_input=tool_call["input"],
+                        tool_result=tool_result.get("result"),
+                    )
+
+                # NEW LOGIC: Check if write_file was called and trigger memory optimization immediately
+
+                # Determine guidance based on results
+                has_error = self._check_tool_results_for_errors(tool_results)
+                files_count = code_agent.get_files_implemented_count()
+
+                if has_error:
+                    guidance = self._generate_error_guidance()
+                else:
+                    guidance = self._generate_success_guidance(files_count)
+
+                compiled_response = self._compile_user_response(tool_results, guidance)
+                messages.append({"role": "user", "content": compiled_response})
+
+                # NEW LOGIC: Apply memory optimization immediately after write_file detection
+                if memory_agent.should_trigger_memory_optimization(
+                    messages, code_agent.get_files_implemented_count()
+                ):
+                    # Memory optimization triggered
+
+                    # Apply concise memory optimization
+                    files_implemented_count = code_agent.get_files_implemented_count()
+                    current_system_message = code_agent.get_system_prompt()
+                    messages = memory_agent.apply_memory_optimization(
+                        current_system_message, messages, files_implemented_count
+                    )
+
+                    # Memory optimization completed
+
+            else:
+                files_count = code_agent.get_files_implemented_count()
+                no_tools_guidance = self._generate_no_tools_guidance(files_count)
+                messages.append({"role": "user", "content": no_tools_guidance})
+
+            # Check for analysis loop and provide corrective guidance
+            if code_agent.is_in_analysis_loop():
+                analysis_loop_guidance = code_agent.get_analysis_loop_guidance()
+                messages.append({"role": "user", "content": analysis_loop_guidance})
+                self.logger.warning(
+                    "Analysis loop detected and corrective guidance provided"
+                )
+
+            # Record file implementations in memory agent (for the current round)
+            for file_info in code_agent.get_implementation_summary()["completed_files"]:
+                memory_agent.record_file_implementation(file_info["file"])
+
+            # REMOVED: Old memory optimization logic - now happens immediately after write_file
+            # Memory optimization is now triggered immediately after write_file detection
+
+            # Start new round for next iteration, sync with workflow iteration
+            memory_agent.start_new_round(iteration=iteration)
+
+            # Check completion
+            if any(
+                keyword in response_content.lower()
+                for keyword in [
+                    "all files implemented",
+                    "all phases completed",
+                    "reproduction plan fully implemented",
+                    "all code of repo implementation complete",
+                ]
+            ):
+                self.logger.info("Code implementation declared complete")
+                break
+
+            # Emergency trim if too long
+            if len(messages) > 50:
+                self.logger.warning(
+                    "Emergency message trim - applying concise memory optimization"
+                )
+
+                current_system_message = code_agent.get_system_prompt()
+                files_implemented_count = code_agent.get_files_implemented_count()
+                messages = memory_agent.apply_memory_optimization(
+                    current_system_message, messages, files_implemented_count
+                )
+
+        return await self._generate_pure_code_final_report_with_concise_agents(
+            iteration, time.time() - start_time, code_agent, memory_agent
+        )
+
+    # ==================== 4. MCP Agent and LLM Communication Management (Communication Layer) ====================
+
+    async def _initialize_mcp_agent(self, code_directory: str):
+        """Initialize MCP agent and connect to code-implementation server"""
+        try:
+            self.mcp_agent = Agent(
+                name="CodeImplementationAgent",
+                instruction="You are a code implementation assistant, using MCP tools to implement paper code replication.",
+                server_names=["code-implementation", "code-reference-indexer"],
+            )
+
+            await self.mcp_agent.__aenter__()
+            llm = await self.mcp_agent.attach_llm(
+                get_preferred_llm_class(self.config_path)
+            )
+
+            # Set workspace to the target code directory
+            workspace_result = await self.mcp_agent.call_tool(
+                "set_workspace", {"workspace_path": code_directory}
+            )
+            self.logger.info(f"Workspace setup result: {workspace_result}")
+
+            return llm
+
+        except Exception as e:
+            self.logger.error(f"Failed to initialize MCP agent: {e}")
+            if self.mcp_agent:
+                try:
+                    await self.mcp_agent.__aexit__(None, None, None)
+                except Exception:
+                    pass
+                self.mcp_agent = None
+            raise
+
+    async def _cleanup_mcp_agent(self):
+        """Clean up MCP agent resources"""
+        if self.mcp_agent:
+            try:
+                await self.mcp_agent.__aexit__(None, None, None)
+                self.logger.info("MCP agent connection closed")
+            except Exception as e:
+                self.logger.warning(f"Error closing MCP agent: {e}")
+            finally:
+                self.mcp_agent = None
+
+    async def _initialize_llm_client(self):
+        """Initialize LLM client (Anthropic or OpenAI) based on API key availability"""
+        # 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=20,
+                    messages=[{"role": "user", "content": "test"}],
+                )
+                self.logger.info(
+                    f"Using Anthropic API with model: {self.default_models['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
+                # Try max_tokens first, fallback to max_completion_tokens if unsupported
+                try:
+                    await client.chat.completions.create(
+                        model=self.default_models["openai"],
+                        max_tokens=20,
+                        messages=[{"role": "user", "content": "test"}],
+                    )
+                except Exception as e:
+                    if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
+                        # Retry with max_completion_tokens for models that require it
+                        await client.chat.completions.create(
+                            model=self.default_models["openai"],
+                            max_completion_tokens=20,
+                            messages=[{"role": "user", "content": "test"}],
+                        )
+                    else:
+                        raise
+                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}")
+                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_with_tools(
+        self, client, client_type, system_message, messages, tools, max_tokens=8192
+    ):
+        """Call LLM with tools"""
+        try:
+            if client_type == "anthropic":
+                return await self._call_anthropic_with_tools(
+                    client, system_message, messages, tools, max_tokens
+                )
+            elif client_type == "openai":
+                return await self._call_openai_with_tools(
+                    client, system_message, messages, tools, max_tokens
+                )
+            else:
+                raise ValueError(f"Unsupported client type: {client_type}")
+        except Exception as e:
+            self.logger.error(f"LLM call failed: {e}")
+            raise
+
+    async def _call_anthropic_with_tools(
+        self, client, system_message, messages, tools, max_tokens
+    ):
+        """Call Anthropic API"""
+        validated_messages = self._validate_messages(messages)
+        if not validated_messages:
+            validated_messages = [
+                {"role": "user", "content": "Please continue implementing code"}
+            ]
+
+        try:
+            response = await client.messages.create(
+                model=self.default_models["anthropic"],
+                system=system_message,
+                messages=validated_messages,
+                tools=tools,
+                max_tokens=max_tokens,
+                temperature=0.2,
+            )
+        except Exception as e:
+            self.logger.error(f"Anthropic API call failed: {e}")
+            raise
+
+        content = ""
+        tool_calls = []
+
+        for block in response.content:
+            if block.type == "text":
+                content += block.text
+            elif block.type == "tool_use":
+                tool_calls.append(
+                    {"id": block.id, "name": block.name, "input": block.input}
+                )
+
+        return {"content": content, "tool_calls": tool_calls}
+
+    async def _call_openai_with_tools(
+        self, client, system_message, messages, tools, max_tokens
+    ):
+        """Call OpenAI API"""
+        openai_tools = []
+        for tool in tools:
+            openai_tools.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": tool["name"],
+                        "description": tool["description"],
+                        "parameters": tool["input_schema"],
+                    },
+                }
+            )
+
+        openai_messages = [{"role": "system", "content": system_message}]
+        openai_messages.extend(messages)
+
+        # Try max_tokens first, fallback to max_completion_tokens if unsupported
+        try:
+            response = await client.chat.completions.create(
+                model=self.default_models["openai"],
+                messages=openai_messages,
+                tools=openai_tools if openai_tools else None,
+                max_tokens=max_tokens,
+                temperature=0.2,
+            )
+        except Exception as e:
+            if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
+                # Retry with max_completion_tokens for models that require it
+                response = await client.chat.completions.create(
+                    model=self.default_models["openai"],
+                    messages=openai_messages,
+                    tools=openai_tools if openai_tools else None,
+                    max_completion_tokens=max_tokens,
+                )
+            else:
+                raise
+
+        message = response.choices[0].message
+        content = message.content or ""
+
+        tool_calls = []
+        if message.tool_calls:
+            for tool_call in message.tool_calls:
+                tool_calls.append(
+                    {
+                        "id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "input": json.loads(tool_call.function.arguments),
+                    }
+                )
+
+        return {"content": content, "tool_calls": tool_calls}
+
+    # ==================== 5. Tools and Utility Methods (Utility Layer) ====================
+
+    def _validate_messages(self, messages: List[Dict]) -> List[Dict]:
+        """Validate and clean message list"""
+        valid_messages = []
+        for msg in messages:
+            content = msg.get("content", "").strip()
+            if content:
+                valid_messages.append(
+                    {"role": msg.get("role", "user"), "content": content}
+                )
+            else:
+                self.logger.warning(f"Skipping empty message: {msg}")
+        return valid_messages
+
+    def _prepare_mcp_tool_definitions(self) -> List[Dict[str, Any]]:
+        """Prepare tool definitions in Anthropic API standard format"""
+        return get_mcp_tools("code_implementation")
+
+    def _check_tool_results_for_errors(self, tool_results: List[Dict]) -> bool:
+        """Check tool results for errors"""
+        for result in tool_results:
+            try:
+                if hasattr(result["result"], "content") and result["result"].content:
+                    content_text = result["result"].content[0].text
+                    parsed_result = json.loads(content_text)
+                    if parsed_result.get("status") == "error":
+                        return True
+                elif isinstance(result["result"], str):
+                    if "error" in result["result"].lower():
+                        return True
+            except (json.JSONDecodeError, AttributeError, IndexError):
+                result_str = str(result["result"])
+                if "error" in result_str.lower():
+                    return True
+        return False
+
+    # ==================== 6. User Interaction and Feedback (Interaction Layer) ====================
+
+    def _generate_success_guidance(self, files_count: int) -> str:
+        """Generate concise success guidance for continuing implementation"""
+        return f"""✅ File implementation completed successfully!
+
+📊 **Progress Status:** {files_count} files implemented
+
+🎯 **Next Action:** Check if ALL files from the reproduction plan are implemented.
+
+⚡ **Decision Process:**
+1. **If ALL files are implemented:** Use `execute_python` or `execute_bash` to test the complete implementation, then respond "**implementation complete**" to end the conversation
+2. **If MORE files need implementation:** Continue with dependency-aware workflow:
+   - **Start with `read_code_mem`** to understand existing implementations and dependencies
+   - **Then `write_file`** to implement the new component
+   - **Finally: Test** if needed
+
+💡 **Key Point:** Always verify completion status before continuing with new file creation."""
+
+    def _generate_error_guidance(self) -> str:
+        """Generate error guidance for handling issues"""
+        return """❌ Error detected during file implementation.
+
+🔧 **Action Required:**
+1. Review the error details above
+2. Fix the identified issue
+3. **Check if ALL files from the reproduction plan are implemented:**
+   - **If YES:** Use `execute_python` or `execute_bash` to test the complete implementation, then respond "**implementation complete**" to end the conversation
+   - **If NO:** Continue with proper development cycle for next file:
+     - **Start with `read_code_mem`** to understand existing implementations
+     - **Then `write_file`** to implement properly
+     - **Test** if needed
+4. Ensure proper error handling in future implementations
+
+💡 **Remember:** Always verify if all planned files are implemented before continuing with new file creation."""
+
+    def _generate_no_tools_guidance(self, files_count: int) -> str:
+        """Generate concise guidance when no tools are called"""
+        return f"""⚠️ No tool calls detected in your response.
+
+📊 **Current Progress:** {files_count} files implemented
+
+🚨 **Action Required:** You must use tools. **FIRST check if ALL files from the reproduction plan are implemented:**
+
+⚡ **Decision Process:**
+1. **If ALL files are implemented:** Use `execute_python` or `execute_bash` to test the complete implementation, then respond "**implementation complete**" to end the conversation
+2. **If MORE files need implementation:** Follow the development cycle:
+   - **Start with `read_code_mem`** to understand existing implementations
+   - **Then `write_file`** to implement the new component
+   - **Finally: Test** if needed
+
+🚨 **Critical:** Always verify completion status first, then use appropriate tools - not just explanations!"""
+
+    def _compile_user_response(self, tool_results: List[Dict], guidance: str) -> str:
+        """Compile tool results and guidance into a single user response"""
+        response_parts = []
+
+        if tool_results:
+            response_parts.append("🔧 **Tool Execution Results:**")
+            for tool_result in tool_results:
+                tool_name = tool_result["tool_name"]
+                result_content = tool_result["result"]
+                response_parts.append(
+                    f"```\nTool: {tool_name}\nResult: {result_content}\n```"
+                )
+
+        if guidance:
+            response_parts.append("\n" + guidance)
+
+        return "\n\n".join(response_parts)
+
+    # ==================== 7. Reporting and Output (Output Layer) ====================
+
+    async def _generate_pure_code_final_report_with_concise_agents(
+        self,
+        iterations: int,
+        elapsed_time: float,
+        code_agent: CodeImplementationAgent,
+        memory_agent: ConciseMemoryAgent,
+    ):
+        """Generate final report using concise agent statistics"""
+        try:
+            code_stats = code_agent.get_implementation_statistics()
+            memory_stats = memory_agent.get_memory_statistics(
+                code_stats["files_implemented_count"]
+            )
+
+            if self.mcp_agent:
+                history_result = await self.mcp_agent.call_tool(
+                    "get_operation_history", {"last_n": 30}
+                )
+                history_data = (
+                    json.loads(history_result)
+                    if isinstance(history_result, str)
+                    else history_result
+                )
+            else:
+                history_data = {"total_operations": 0, "history": []}
+
+            write_operations = 0
+            files_created = []
+            if "history" in history_data:
+                for item in history_data["history"]:
+                    if item.get("action") == "write_file":
+                        write_operations += 1
+                        file_path = item.get("details", {}).get("file_path", "unknown")
+                        files_created.append(file_path)
+
+            report = f"""
+# Pure Code Implementation Completion Report (Write-File-Based Memory Mode)
+
+## Execution Summary
+- Implementation iterations: {iterations}
+- Total elapsed time: {elapsed_time:.2f} seconds
+- Files implemented: {code_stats['total_files_implemented']}
+- File write operations: {write_operations}
+- Total MCP operations: {history_data.get('total_operations', 0)}
+
+## Read Tools Configuration
+- Read tools enabled: {code_stats['read_tools_status']['read_tools_enabled']}
+- Status: {code_stats['read_tools_status']['status']}
+- Tools affected: {', '.join(code_stats['read_tools_status']['tools_affected'])}
+
+## Agent Performance
+### Code Implementation Agent
+- Files tracked: {code_stats['files_implemented_count']}
+- Technical decisions: {code_stats['technical_decisions_count']}
+- Constraints tracked: {code_stats['constraints_count']}
+- Architecture notes: {code_stats['architecture_notes_count']}
+- Dependency analysis performed: {code_stats['dependency_analysis_count']}
+- Files read for dependencies: {code_stats['files_read_for_dependencies']}
+- Last summary triggered at file count: {code_stats['last_summary_file_count']}
+
+### Concise Memory Agent (Write-File-Based)
+- Last write_file detected: {memory_stats['last_write_file_detected']}
+- Should clear memory next: {memory_stats['should_clear_memory_next']}
+- Files implemented count: {memory_stats['implemented_files_tracked']}
+- Current round: {memory_stats['current_round']}
+- Concise mode active: {memory_stats['concise_mode_active']}
+- Current round tool results: {memory_stats['current_round_tool_results']}
+- Essential tools recorded: {memory_stats['essential_tools_recorded']}
+
+## Files Created
+"""
+            for file_path in files_created[-20:]:
+                report += f"- {file_path}\n"
+
+            if len(files_created) > 20:
+                report += f"... and {len(files_created) - 20} more files\n"
+
+            report += """
+## Architecture Features
+✅ WRITE-FILE-BASED Memory Agent - Clear after each file generation
+✅ After write_file: Clear history → Keep system prompt + initial plan + tool results
+✅ Tool accumulation: read_code_mem, read_file, search_reference_code until next write_file
+✅ Clean memory cycle: write_file → clear → accumulate → write_file → clear
+✅ Essential tool recording with write_file detection
+✅ Specialized agent separation for clean code organization
+✅ MCP-compliant tool execution
+✅ Production-grade code with comprehensive type hints
+✅ Intelligent dependency analysis and file reading
+✅ Automated read_file usage for implementation context
+✅ Eliminates conversation clutter between file generations
+✅ Focused memory for efficient next file generation
+"""
+            return report
+
+        except Exception as e:
+            self.logger.error(f"Failed to generate final report: {e}")
+            return f"Failed to generate final report: {str(e)}"
+
+
+async def main():
+    """Main function for running the workflow"""
+    # Configure root logger carefully to avoid duplicates
+    root_logger = logging.getLogger()
+    if not root_logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter("%(levelname)s:%(name)s:%(message)s")
+        handler.setFormatter(formatter)
+        root_logger.addHandler(handler)
+        root_logger.setLevel(logging.INFO)
+
+    workflow = CodeImplementationWorkflow()
+
+    print("=" * 60)
+    print("Code Implementation Workflow with UNIFIED Reference Indexer")
+    print("=" * 60)
+    print("Select mode:")
+    print("1. Test Code Reference Indexer Integration")
+    print("2. Run Full Implementation Workflow")
+    print("3. Run Implementation with Pure Code Mode")
+    print("4. Test Read Tools Configuration")
+
+    # mode_choice = input("Enter choice (1-4, default: 3): ").strip()
+
+    # For testing purposes, we'll run the test first
+    # if mode_choice == "4":
+    #     print("Testing Read Tools Configuration...")
+
+    #     # Create a test workflow normally
+    #     test_workflow = CodeImplementationWorkflow()
+
+    #     # Create a mock code agent for testing
+    #     print("\n🧪 Testing with read tools DISABLED:")
+    #     test_agent_disabled = CodeImplementationAgent(None, enable_read_tools=False)
+    #     await test_agent_disabled.test_read_tools_configuration()
+
+    #     print("\n🧪 Testing with read tools ENABLED:")
+    #     test_agent_enabled = CodeImplementationAgent(None, enable_read_tools=True)
+    #     await test_agent_enabled.test_read_tools_configuration()
+
+    #     print("✅ Read tools configuration testing completed!")
+    #     return
+
+    # print("Running Code Reference Indexer Integration Test...")
+
+    test_success = True
+    if test_success:
+        print("\n" + "=" * 60)
+        print("🎉 UNIFIED Code Reference Indexer Integration Test PASSED!")
+        print("🔧 Three-step process successfully merged into ONE tool")
+        print("=" * 60)
+
+        # Ask if user wants to continue with actual workflow
+        print("\nContinuing with workflow execution...")
+
+        plan_file = "/Users/lizongwei/Reasearch/DeepCode_Base/DeepCode/deepcode_lab/papers/1/initial_plan.txt"
+        # plan_file = "/data2/bjdwhzzh/project-hku/Code-Agent2.0/Code-Agent/deepcode-mcp/agent_folders/papers/1/initial_plan.txt"
+        target_directory = (
+            "/Users/lizongwei/Reasearch/DeepCode_Base/DeepCode/deepcode_lab/papers/1/"
+        )
+        print("Implementation Mode Selection:")
+        print("1. Pure Code Implementation Mode (Recommended)")
+        print("2. Iterative Implementation Mode")
+
+        pure_code_mode = True
+        mode_name = "Pure Code Implementation Mode with Memory Agent Architecture + Code Reference Indexer"
+        print(f"Using: {mode_name}")
+
+        # Configure read tools - modify this parameter to enable/disable read tools
+        enable_read_tools = (
+            True  # Set to False to disable read_file and read_code_mem tools
+        )
+        read_tools_status = "ENABLED" if enable_read_tools else "DISABLED"
+        print(f"🔧 Read tools (read_file, read_code_mem): {read_tools_status}")
+
+        # NOTE: To test without read tools, change the line above to:
+        # enable_read_tools = False
+
+        result = await workflow.run_workflow(
+            plan_file,
+            target_directory=target_directory,
+            pure_code_mode=pure_code_mode,
+            enable_read_tools=enable_read_tools,
+        )
+
+        print("=" * 60)
+        print("Workflow Execution Results:")
+        print(f"Status: {result['status']}")
+        print(f"Mode: {mode_name}")
+
+        if result["status"] == "success":
+            print(f"Code Directory: {result['code_directory']}")
+            print(f"MCP Architecture: {result.get('mcp_architecture', 'unknown')}")
+            print("Execution completed!")
+        else:
+            print(f"Error Message: {result['message']}")
+
+        print("=" * 60)
+        print(
+            "✅ Using Standard MCP Architecture with Memory Agent + Code Reference Indexer"
+        )
+
+    else:
+        print("\n" + "=" * 60)
+        print("❌ Code Reference Indexer Integration Test FAILED!")
+        print("Please check the configuration and try again.")
+        print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

projects/ui/DeepCode/workflows/code_implementation_workflow_index.py

@@ -0,0 +1,997 @@
+"""
+Paper Code Implementation Workflow - MCP-compliant Iterative Development
+
+Features:
+1. File Tree Creation
+2. Code Implementation - Based on aisi-basic-agent iterative development
+
+MCP Architecture:
+- MCP Server: tools/code_implementation_server.py
+- MCP Client: Called through mcp_agent framework
+- Configuration: mcp_agent.config.yaml
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import time
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+
+# MCP Agent imports
+from mcp_agent.agents.agent import Agent
+
+# Local imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from prompts.code_prompts import STRUCTURE_GENERATOR_PROMPT
+from prompts.code_prompts import (
+    PURE_CODE_IMPLEMENTATION_SYSTEM_PROMPT_INDEX,
+)
+from workflows.agents import CodeImplementationAgent
+from workflows.agents.memory_agent_concise import ConciseMemoryAgent
+from config.mcp_tool_definitions_index import get_mcp_tools
+from utils.llm_utils import get_preferred_llm_class, get_default_models
+# DialogueLogger removed - no longer needed
+
+
+class CodeImplementationWorkflowWithIndex:
+    """
+    Paper Code Implementation Workflow Manager with Code Reference Indexer
+
+    Uses standard MCP architecture with enhanced indexing capabilities:
+    1. Connect to code-implementation server via MCP client
+    2. Use MCP protocol for tool calls
+    3. Support workspace management and operation history tracking
+    4. Integrated code reference indexer for enhanced code understanding
+    """
+
+    # ==================== 1. Class Initialization and Configuration (Infrastructure Layer) ====================
+
+    def __init__(self, config_path: str = "mcp_agent.secrets.yaml"):
+        """Initialize workflow with configuration"""
+        self.config_path = config_path
+        self.api_config = self._load_api_config()
+        self.default_models = get_default_models("mcp_agent.config.yaml")
+        self.logger = self._create_logger()
+        self.mcp_agent = None
+        self.enable_read_tools = (
+            True  # Default value, will be overridden by run_workflow parameter
+        )
+
+    def _load_api_config(self) -> Dict[str, Any]:
+        """Load API configuration from YAML file"""
+        try:
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        except Exception as e:
+            raise Exception(f"Failed to load API config: {e}")
+
+    def _create_logger(self) -> logging.Logger:
+        """Create and configure logger"""
+        logger = logging.getLogger(__name__)
+        # Don't add handlers to child loggers - let them propagate to root
+        logger.setLevel(logging.INFO)
+        return logger
+
+    def _read_plan_file(self, plan_file_path: str) -> str:
+        """Read implementation plan file"""
+        plan_path = Path(plan_file_path)
+        if not plan_path.exists():
+            raise FileNotFoundError(
+                f"Implementation plan file not found: {plan_file_path}"
+            )
+
+        with open(plan_path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    def _check_file_tree_exists(self, target_directory: str) -> bool:
+        """Check if file tree structure already exists"""
+        code_directory = os.path.join(target_directory, "generate_code")
+        return os.path.exists(code_directory) and len(os.listdir(code_directory)) > 0
+
+    # ==================== 2. Public Interface Methods (External API Layer) ====================
+
+    async def run_workflow(
+        self,
+        plan_file_path: str,
+        target_directory: Optional[str] = None,
+        pure_code_mode: bool = False,
+        enable_read_tools: bool = True,
+    ):
+        """Run complete workflow - Main public interface"""
+        # Set the read tools configuration
+        self.enable_read_tools = enable_read_tools
+
+        try:
+            plan_content = self._read_plan_file(plan_file_path)
+
+            if target_directory is None:
+                target_directory = str(Path(plan_file_path).parent)
+
+            # Calculate code directory for workspace alignment
+            code_directory = os.path.join(target_directory, "generate_code")
+
+            self.logger.info("=" * 80)
+            self.logger.info("🚀 STARTING CODE IMPLEMENTATION WORKFLOW")
+            self.logger.info("=" * 80)
+            self.logger.info(f"📄 Plan file: {plan_file_path}")
+            self.logger.info(f"📂 Plan file parent: {target_directory}")
+            self.logger.info(f"🎯 Code directory (MCP workspace): {code_directory}")
+            self.logger.info(
+                f"⚙️  Read tools: {'ENABLED' if self.enable_read_tools else 'DISABLED'}"
+            )
+            self.logger.info("=" * 80)
+
+            results = {}
+
+            # Check if file tree exists
+            if self._check_file_tree_exists(target_directory):
+                self.logger.info("File tree exists, skipping creation")
+                results["file_tree"] = "Already exists, skipped creation"
+            else:
+                self.logger.info("Creating file tree...")
+                results["file_tree"] = await self.create_file_structure(
+                    plan_content, target_directory
+                )
+
+            # Code implementation
+            if pure_code_mode:
+                self.logger.info("Starting pure code implementation...")
+                results["code_implementation"] = await self.implement_code_pure(
+                    plan_content, target_directory, code_directory
+                )
+            else:
+                pass
+
+            self.logger.info("Workflow execution successful")
+
+            return {
+                "status": "success",
+                "plan_file": plan_file_path,
+                "target_directory": target_directory,
+                "code_directory": os.path.join(target_directory, "generate_code"),
+                "results": results,
+                "mcp_architecture": "standard",
+            }
+
+        except Exception as e:
+            self.logger.error(f"Workflow execution failed: {e}")
+
+            return {"status": "error", "message": str(e), "plan_file": plan_file_path}
+        finally:
+            await self._cleanup_mcp_agent()
+
+    async def create_file_structure(
+        self, plan_content: str, target_directory: str
+    ) -> str:
+        """Create file tree structure based on implementation plan"""
+        self.logger.info("Starting file tree creation...")
+
+        structure_agent = Agent(
+            name="StructureGeneratorAgent",
+            instruction=STRUCTURE_GENERATOR_PROMPT,
+            server_names=["command-executor"],
+        )
+
+        async with structure_agent:
+            creator = await structure_agent.attach_llm(
+                get_preferred_llm_class(self.config_path)
+            )
+
+            message = f"""Analyze the following implementation plan and generate shell commands to create the file tree structure.
+
+Target Directory: {target_directory}/generate_code
+
+Implementation Plan:
+{plan_content}
+
+Tasks:
+1. Find the file tree structure in the implementation plan
+2. Generate shell commands (mkdir -p, touch) to create that structure
+3. Use the execute_commands tool to run the commands and create the file structure
+
+Requirements:
+- Use mkdir -p to create directories
+- Use touch to create files
+- Include __init__.py file for Python packages
+- Use relative paths to the target directory
+- Execute commands to actually create the file structure"""
+
+            result = await creator.generate_str(message=message)
+            self.logger.info("File tree structure creation completed")
+            return result
+
+    async def implement_code_pure(
+        self, plan_content: str, target_directory: str, code_directory: str = None
+    ) -> str:
+        """Pure code implementation - focus on code writing without testing"""
+        self.logger.info("Starting pure code implementation (no testing)...")
+
+        # Use provided code_directory or calculate it (for backwards compatibility)
+        if code_directory is None:
+            code_directory = os.path.join(target_directory, "generate_code")
+
+        self.logger.info(f"🎯 Using code directory (MCP workspace): {code_directory}")
+
+        if not os.path.exists(code_directory):
+            raise FileNotFoundError(
+                "File tree structure not found, please run file tree creation first"
+            )
+
+        try:
+            client, client_type = await self._initialize_llm_client()
+            await self._initialize_mcp_agent(code_directory)
+
+            tools = self._prepare_mcp_tool_definitions()
+            system_message = PURE_CODE_IMPLEMENTATION_SYSTEM_PROMPT_INDEX
+            messages = []
+
+            #             implementation_message = f"""**TASK: Implement Research Paper Reproduction Code**
+
+            # You are implementing a complete, working codebase that reproduces the core algorithms, experiments, and methods described in a research paper. Your goal is to create functional code that can replicate the paper's key results and contributions.
+
+            # **What you need to do:**
+            # - Analyze the paper content and reproduction plan to understand requirements
+            # - Implement all core algorithms mentioned in the main body of the paper
+            # - Create the necessary components following the planned architecture
+            # - Test each component to ensure functionality
+            # - Integrate components into a cohesive, executable system
+            # - Focus on reproducing main contributions rather than appendix-only experiments
+
+            # **RESOURCES:**
+            # - **Paper & Reproduction Plan**: `{target_directory}/` (contains .md paper files and initial_plan.txt with detailed implementation guidance)
+            # - **Reference Code Indexes**: `{target_directory}/indexes/` (JSON files with implementation patterns from related codebases)
+            # - **Implementation Directory**: `{code_directory}/` (your working directory for all code files)
+
+            # **CURRENT OBJECTIVE:**
+            # Start by reading the reproduction plan (`{target_directory}/initial_plan.txt`) to understand the implementation strategy, then examine the paper content to identify the first priority component to implement. Use the search_code tool to find relevant reference implementations from the indexes directory (`{target_directory}/indexes/*.json`) before coding.
+
+            # ---
+            # **START:** Review the plan above and begin implementation."""
+            implementation_message = f"""**Task: Implement code based on the following reproduction plan**
+
+**Code Reproduction Plan:**
+{plan_content}
+
+**Working Directory:** {code_directory}
+
+**Current Objective:** Begin implementation by analyzing the plan structure, examining the current project layout, and implementing the first foundation file according to the plan's priority order."""
+
+            messages.append({"role": "user", "content": implementation_message})
+
+            result = await self._pure_code_implementation_loop(
+                client,
+                client_type,
+                system_message,
+                messages,
+                tools,
+                plan_content,
+                target_directory,
+            )
+
+            return result
+
+        finally:
+            await self._cleanup_mcp_agent()
+
+    # ==================== 3. Core Business Logic (Implementation Layer) ====================
+
+    async def _pure_code_implementation_loop(
+        self,
+        client,
+        client_type,
+        system_message,
+        messages,
+        tools,
+        plan_content,
+        target_directory,
+    ):
+        """Pure code implementation loop with memory optimization and phase consistency"""
+        max_iterations = 500
+        iteration = 0
+        start_time = time.time()
+        max_time = 2400  # 40 minutes
+
+        # Initialize specialized agents
+        code_agent = CodeImplementationAgent(
+            self.mcp_agent, self.logger, self.enable_read_tools
+        )
+        memory_agent = ConciseMemoryAgent(plan_content, self.logger, target_directory)
+
+        # Log read tools configuration
+        read_tools_status = "ENABLED" if self.enable_read_tools else "DISABLED"
+        self.logger.info(
+            f"🔧 Read tools (read_file, read_code_mem): {read_tools_status}"
+        )
+        if not self.enable_read_tools:
+            self.logger.info(
+                "🚫 No read mode: read_file and read_code_mem tools will be skipped"
+            )
+
+        # Connect code agent with memory agent for summary generation
+        # Note: Concise memory agent doesn't need LLM client for summary generation
+        code_agent.set_memory_agent(memory_agent, client, client_type)
+
+        # Initialize memory agent with iteration 0
+        memory_agent.start_new_round(iteration=0)
+
+        while iteration < max_iterations:
+            iteration += 1
+            elapsed_time = time.time() - start_time
+
+            if elapsed_time > max_time:
+                self.logger.warning(f"Time limit reached: {elapsed_time:.2f}s")
+                break
+
+            # # Test simplified memory approach if we have files implemented
+            # if iteration == 5 and code_agent.get_files_implemented_count() > 0:
+            #     self.logger.info("🧪 Testing simplified memory approach...")
+            #     test_results = await memory_agent.test_simplified_memory_approach()
+            #     self.logger.info(f"Memory test results: {test_results}")
+
+            # self.logger.info(f"Pure code implementation iteration {iteration}: generating code")
+
+            messages = self._validate_messages(messages)
+            current_system_message = code_agent.get_system_prompt()
+
+            # Round logging removed
+
+            # Call LLM
+            response = await self._call_llm_with_tools(
+                client, client_type, current_system_message, messages, tools
+            )
+
+            response_content = response.get("content", "").strip()
+            if not response_content:
+                response_content = "Continue implementing code files..."
+
+            messages.append({"role": "assistant", "content": response_content})
+
+            # Handle tool calls
+            if response.get("tool_calls"):
+                tool_results = await code_agent.execute_tool_calls(
+                    response["tool_calls"]
+                )
+
+                # Record essential tool results in concise memory agent
+                for tool_call, tool_result in zip(response["tool_calls"], tool_results):
+                    memory_agent.record_tool_result(
+                        tool_name=tool_call["name"],
+                        tool_input=tool_call["input"],
+                        tool_result=tool_result.get("result"),
+                    )
+
+                # NEW LOGIC: Check if write_file was called and trigger memory optimization immediately
+
+                # Determine guidance based on results
+                has_error = self._check_tool_results_for_errors(tool_results)
+                files_count = code_agent.get_files_implemented_count()
+
+                if has_error:
+                    guidance = self._generate_error_guidance()
+                else:
+                    guidance = self._generate_success_guidance(files_count)
+
+                compiled_response = self._compile_user_response(tool_results, guidance)
+                messages.append({"role": "user", "content": compiled_response})
+
+                # NEW LOGIC: Apply memory optimization immediately after write_file detection
+                if memory_agent.should_trigger_memory_optimization(
+                    messages, code_agent.get_files_implemented_count()
+                ):
+                    # Memory optimization triggered
+
+                    # Apply concise memory optimization
+                    files_implemented_count = code_agent.get_files_implemented_count()
+                    current_system_message = code_agent.get_system_prompt()
+                    messages = memory_agent.apply_memory_optimization(
+                        current_system_message, messages, files_implemented_count
+                    )
+
+                    # Memory optimization completed
+
+            else:
+                files_count = code_agent.get_files_implemented_count()
+                no_tools_guidance = self._generate_no_tools_guidance(files_count)
+                messages.append({"role": "user", "content": no_tools_guidance})
+
+            # Check for analysis loop and provide corrective guidance
+            if code_agent.is_in_analysis_loop():
+                analysis_loop_guidance = code_agent.get_analysis_loop_guidance()
+                messages.append({"role": "user", "content": analysis_loop_guidance})
+                self.logger.warning(
+                    "Analysis loop detected and corrective guidance provided"
+                )
+
+            # Record file implementations in memory agent (for the current round)
+            for file_info in code_agent.get_implementation_summary()["completed_files"]:
+                memory_agent.record_file_implementation(file_info["file"])
+
+            # REMOVED: Old memory optimization logic - now happens immediately after write_file
+            # Memory optimization is now triggered immediately after write_file detection
+
+            # Start new round for next iteration, sync with workflow iteration
+            memory_agent.start_new_round(iteration=iteration)
+
+            # Check completion
+            if any(
+                keyword in response_content.lower()
+                for keyword in [
+                    "all files implemented",
+                    "all phases completed",
+                    "reproduction plan fully implemented",
+                    "all code of repo implementation complete",
+                ]
+            ):
+                self.logger.info("Code implementation declared complete")
+                break
+
+            # Emergency trim if too long
+            if len(messages) > 50:
+                self.logger.warning(
+                    "Emergency message trim - applying concise memory optimization"
+                )
+
+                current_system_message = code_agent.get_system_prompt()
+                files_implemented_count = code_agent.get_files_implemented_count()
+                messages = memory_agent.apply_memory_optimization(
+                    current_system_message, messages, files_implemented_count
+                )
+
+        return await self._generate_pure_code_final_report_with_concise_agents(
+            iteration, time.time() - start_time, code_agent, memory_agent
+        )
+
+    # ==================== 4. MCP Agent and LLM Communication Management (Communication Layer) ====================
+
+    async def _initialize_mcp_agent(self, code_directory: str):
+        """Initialize MCP agent and connect to code-implementation server"""
+        try:
+            self.mcp_agent = Agent(
+                name="CodeImplementationAgent",
+                instruction="You are a code implementation assistant, using MCP tools to implement paper code replication.",
+                server_names=["code-implementation", "code-reference-indexer"],
+            )
+
+            await self.mcp_agent.__aenter__()
+            llm = await self.mcp_agent.attach_llm(
+                get_preferred_llm_class(self.config_path)
+            )
+
+            # Set workspace to the target code directory
+            workspace_result = await self.mcp_agent.call_tool(
+                "set_workspace", {"workspace_path": code_directory}
+            )
+            self.logger.info(f"Workspace setup result: {workspace_result}")
+
+            return llm
+
+        except Exception as e:
+            self.logger.error(f"Failed to initialize MCP agent: {e}")
+            if self.mcp_agent:
+                try:
+                    await self.mcp_agent.__aexit__(None, None, None)
+                except Exception:
+                    pass
+                self.mcp_agent = None
+            raise
+
+    async def _cleanup_mcp_agent(self):
+        """Clean up MCP agent resources"""
+        if self.mcp_agent:
+            try:
+                await self.mcp_agent.__aexit__(None, None, None)
+                self.logger.info("MCP agent connection closed")
+            except Exception as e:
+                self.logger.warning(f"Error closing MCP agent: {e}")
+            finally:
+                self.mcp_agent = None
+
+    async def _initialize_llm_client(self):
+        """Initialize LLM client (Anthropic or OpenAI) based on API key availability"""
+        # 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=20,
+                    messages=[{"role": "user", "content": "test"}],
+                )
+                self.logger.info(
+                    f"Using Anthropic API with model: {self.default_models['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
+                # Try max_tokens first, fallback to max_completion_tokens if unsupported
+                try:
+                    await client.chat.completions.create(
+                        model=self.default_models["openai"],
+                        max_tokens=20,
+                        messages=[{"role": "user", "content": "test"}],
+                    )
+                except Exception as e:
+                    if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
+                        # Retry with max_completion_tokens for models that require it
+                        await client.chat.completions.create(
+                            model=self.default_models["openai"],
+                            max_completion_tokens=20,
+                            messages=[{"role": "user", "content": "test"}],
+                        )
+                    else:
+                        raise
+                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}")
+                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_with_tools(
+        self, client, client_type, system_message, messages, tools, max_tokens=8192
+    ):
+        """Call LLM with tools"""
+        try:
+            if client_type == "anthropic":
+                return await self._call_anthropic_with_tools(
+                    client, system_message, messages, tools, max_tokens
+                )
+            elif client_type == "openai":
+                return await self._call_openai_with_tools(
+                    client, system_message, messages, tools, max_tokens
+                )
+            else:
+                raise ValueError(f"Unsupported client type: {client_type}")
+        except Exception as e:
+            self.logger.error(f"LLM call failed: {e}")
+            raise
+
+    async def _call_anthropic_with_tools(
+        self, client, system_message, messages, tools, max_tokens
+    ):
+        """Call Anthropic API"""
+        validated_messages = self._validate_messages(messages)
+        if not validated_messages:
+            validated_messages = [
+                {"role": "user", "content": "Please continue implementing code"}
+            ]
+
+        try:
+            response = await client.messages.create(
+                model=self.default_models["anthropic"],
+                system=system_message,
+                messages=validated_messages,
+                tools=tools,
+                max_tokens=max_tokens,
+                temperature=0.2,
+            )
+        except Exception as e:
+            self.logger.error(f"Anthropic API call failed: {e}")
+            raise
+
+        content = ""
+        tool_calls = []
+
+        for block in response.content:
+            if block.type == "text":
+                content += block.text
+            elif block.type == "tool_use":
+                tool_calls.append(
+                    {"id": block.id, "name": block.name, "input": block.input}
+                )
+
+        return {"content": content, "tool_calls": tool_calls}
+
+    async def _call_openai_with_tools(
+        self, client, system_message, messages, tools, max_tokens
+    ):
+        """Call OpenAI API"""
+        openai_tools = []
+        for tool in tools:
+            openai_tools.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": tool["name"],
+                        "description": tool["description"],
+                        "parameters": tool["input_schema"],
+                    },
+                }
+            )
+
+        openai_messages = [{"role": "system", "content": system_message}]
+        openai_messages.extend(messages)
+
+        # Try max_tokens first, fallback to max_completion_tokens if unsupported
+        try:
+            response = await client.chat.completions.create(
+                model=self.default_models["openai"],
+                messages=openai_messages,
+                tools=openai_tools if openai_tools else None,
+                max_tokens=max_tokens,
+                temperature=0.2,
+            )
+        except Exception as e:
+            if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
+                # Retry with max_completion_tokens for models that require it
+                response = await client.chat.completions.create(
+                    model=self.default_models["openai"],
+                    messages=openai_messages,
+                    tools=openai_tools if openai_tools else None,
+                    max_completion_tokens=max_tokens,
+                )
+            else:
+                raise
+
+        message = response.choices[0].message
+        content = message.content or ""
+
+        tool_calls = []
+        if message.tool_calls:
+            for tool_call in message.tool_calls:
+                tool_calls.append(
+                    {
+                        "id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "input": json.loads(tool_call.function.arguments),
+                    }
+                )
+
+        return {"content": content, "tool_calls": tool_calls}
+
+    # ==================== 5. Tools and Utility Methods (Utility Layer) ====================
+
+    def _validate_messages(self, messages: List[Dict]) -> List[Dict]:
+        """Validate and clean message list"""
+        valid_messages = []
+        for msg in messages:
+            content = msg.get("content", "").strip()
+            if content:
+                valid_messages.append(
+                    {"role": msg.get("role", "user"), "content": content}
+                )
+            else:
+                self.logger.warning(f"Skipping empty message: {msg}")
+        return valid_messages
+
+    def _prepare_mcp_tool_definitions(self) -> List[Dict[str, Any]]:
+        """Prepare tool definitions in Anthropic API standard format"""
+        return get_mcp_tools("code_implementation")
+
+    def _check_tool_results_for_errors(self, tool_results: List[Dict]) -> bool:
+        """Check tool results for errors"""
+        for result in tool_results:
+            try:
+                if hasattr(result["result"], "content") and result["result"].content:
+                    content_text = result["result"].content[0].text
+                    parsed_result = json.loads(content_text)
+                    if parsed_result.get("status") == "error":
+                        return True
+                elif isinstance(result["result"], str):
+                    if "error" in result["result"].lower():
+                        return True
+            except (json.JSONDecodeError, AttributeError, IndexError):
+                result_str = str(result["result"])
+                if "error" in result_str.lower():
+                    return True
+        return False
+
+    # ==================== 6. User Interaction and Feedback (Interaction Layer) ====================
+
+    def _generate_success_guidance(self, files_count: int) -> str:
+        """Generate concise success guidance for continuing implementation"""
+        return f"""✅ File implementation completed successfully!
+
+📊 **Progress Status:** {files_count} files implemented
+
+🎯 **Next Action:** Check if ALL files from the reproduction plan are implemented.
+
+⚡ **Decision Process:**
+1. **If ALL files are implemented:** Use `execute_python` or `execute_bash` to test the complete implementation, then respond "**implementation complete**" to end the conversation
+2. **If MORE files need implementation:** Continue with dependency-aware workflow:
+   - **Start with `read_code_mem`** to understand existing implementations and dependencies
+   - **Optionally use `search_code_references`** for reference patterns (OPTIONAL - use for inspiration only, original paper specs take priority)
+   - **Then `write_file`** to implement the new component
+   - **Finally: Test** if needed
+
+💡 **Key Point:** Always verify completion status before continuing with new file creation."""
+
+    def _generate_error_guidance(self) -> str:
+        """Generate error guidance for handling issues"""
+        return """❌ Error detected during file implementation.
+
+🔧 **Action Required:**
+1. Review the error details above
+2. Fix the identified issue
+3. **Check if ALL files from the reproduction plan are implemented:**
+   - **If YES:** Use `execute_python` or `execute_bash` to test the complete implementation, then respond "**implementation complete**" to end the conversation
+   - **If NO:** Continue with proper development cycle for next file:
+     - **Start with `read_code_mem`** to understand existing implementations
+     - **Optionally use `search_code_references`** for reference patterns (OPTIONAL - for inspiration only)
+     - **Then `write_file`** to implement properly
+     - **Test** if needed
+4. Ensure proper error handling in future implementations
+
+💡 **Remember:** Always verify if all planned files are implemented before continuing with new file creation."""
+
+    def _generate_no_tools_guidance(self, files_count: int) -> str:
+        """Generate concise guidance when no tools are called"""
+        return f"""⚠️ No tool calls detected in your response.
+
+📊 **Current Progress:** {files_count} files implemented
+
+🚨 **Action Required:** You must use tools. **FIRST check if ALL files from the reproduction plan are implemented:**
+
+⚡ **Decision Process:**
+1. **If ALL files are implemented:** Use `execute_python` or `execute_bash` to test the complete implementation, then respond "**implementation complete**" to end the conversation
+2. **If MORE files need implementation:** Follow the development cycle:
+   - **Start with `read_code_mem`** to understand existing implementations
+   - **Optionally use `search_code_references`** for reference patterns (OPTIONAL - for inspiration only)
+   - **Then `write_file`** to implement the new component
+   - **Finally: Test** if needed
+
+🚨 **Critical:** Always verify completion status first, then use appropriate tools - not just explanations!"""
+
+    def _compile_user_response(self, tool_results: List[Dict], guidance: str) -> str:
+        """Compile tool results and guidance into a single user response"""
+        response_parts = []
+
+        if tool_results:
+            response_parts.append("🔧 **Tool Execution Results:**")
+            for tool_result in tool_results:
+                tool_name = tool_result["tool_name"]
+                result_content = tool_result["result"]
+                response_parts.append(
+                    f"```\nTool: {tool_name}\nResult: {result_content}\n```"
+                )
+
+        if guidance:
+            response_parts.append("\n" + guidance)
+
+        return "\n\n".join(response_parts)
+
+    # ==================== 7. Reporting and Output (Output Layer) ====================
+
+    async def _generate_pure_code_final_report_with_concise_agents(
+        self,
+        iterations: int,
+        elapsed_time: float,
+        code_agent: CodeImplementationAgent,
+        memory_agent: ConciseMemoryAgent,
+    ):
+        """Generate final report using concise agent statistics"""
+        try:
+            code_stats = code_agent.get_implementation_statistics()
+            memory_stats = memory_agent.get_memory_statistics(
+                code_stats["files_implemented_count"]
+            )
+
+            if self.mcp_agent:
+                history_result = await self.mcp_agent.call_tool(
+                    "get_operation_history", {"last_n": 30}
+                )
+                history_data = (
+                    json.loads(history_result)
+                    if isinstance(history_result, str)
+                    else history_result
+                )
+            else:
+                history_data = {"total_operations": 0, "history": []}
+
+            write_operations = 0
+            files_created = []
+            if "history" in history_data:
+                for item in history_data["history"]:
+                    if item.get("action") == "write_file":
+                        write_operations += 1
+                        file_path = item.get("details", {}).get("file_path", "unknown")
+                        files_created.append(file_path)
+
+            report = f"""
+# Pure Code Implementation Completion Report (Write-File-Based Memory Mode)
+
+## Execution Summary
+- Implementation iterations: {iterations}
+- Total elapsed time: {elapsed_time:.2f} seconds
+- Files implemented: {code_stats['total_files_implemented']}
+- File write operations: {write_operations}
+- Total MCP operations: {history_data.get('total_operations', 0)}
+
+## Read Tools Configuration
+- Read tools enabled: {code_stats['read_tools_status']['read_tools_enabled']}
+- Status: {code_stats['read_tools_status']['status']}
+- Tools affected: {', '.join(code_stats['read_tools_status']['tools_affected'])}
+
+## Agent Performance
+### Code Implementation Agent
+- Files tracked: {code_stats['files_implemented_count']}
+- Technical decisions: {code_stats['technical_decisions_count']}
+- Constraints tracked: {code_stats['constraints_count']}
+- Architecture notes: {code_stats['architecture_notes_count']}
+- Dependency analysis performed: {code_stats['dependency_analysis_count']}
+- Files read for dependencies: {code_stats['files_read_for_dependencies']}
+- Last summary triggered at file count: {code_stats['last_summary_file_count']}
+
+### Concise Memory Agent (Write-File-Based)
+- Last write_file detected: {memory_stats['last_write_file_detected']}
+- Should clear memory next: {memory_stats['should_clear_memory_next']}
+- Files implemented count: {memory_stats['implemented_files_tracked']}
+- Current round: {memory_stats['current_round']}
+- Concise mode active: {memory_stats['concise_mode_active']}
+- Current round tool results: {memory_stats['current_round_tool_results']}
+- Essential tools recorded: {memory_stats['essential_tools_recorded']}
+
+## Files Created
+"""
+            for file_path in files_created[-20:]:
+                report += f"- {file_path}\n"
+
+            if len(files_created) > 20:
+                report += f"... and {len(files_created) - 20} more files\n"
+
+            report += """
+## Architecture Features
+✅ WRITE-FILE-BASED Memory Agent - Clear after each file generation
+✅ After write_file: Clear history → Keep system prompt + initial plan + tool results
+✅ Tool accumulation: read_code_mem, read_file, search_reference_code until next write_file
+✅ Clean memory cycle: write_file → clear → accumulate → write_file → clear
+✅ Essential tool recording with write_file detection
+✅ Specialized agent separation for clean code organization
+✅ MCP-compliant tool execution
+✅ Production-grade code with comprehensive type hints
+✅ Intelligent dependency analysis and file reading
+✅ Automated read_file usage for implementation context
+✅ Eliminates conversation clutter between file generations
+✅ Focused memory for efficient next file generation
+"""
+            return report
+
+        except Exception as e:
+            self.logger.error(f"Failed to generate final report: {e}")
+            return f"Failed to generate final report: {str(e)}"
+
+
+async def main():
+    """Main function for running the workflow"""
+    # Configure root logger carefully to avoid duplicates
+    root_logger = logging.getLogger()
+    if not root_logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter("%(levelname)s:%(name)s:%(message)s")
+        handler.setFormatter(formatter)
+        root_logger.addHandler(handler)
+        root_logger.setLevel(logging.INFO)
+
+    workflow = CodeImplementationWorkflowWithIndex()
+
+    print("=" * 60)
+    print("Code Implementation Workflow with UNIFIED Reference Indexer")
+    print("=" * 60)
+    print("Select mode:")
+    print("1. Test Code Reference Indexer Integration")
+    print("2. Run Full Implementation Workflow")
+    print("3. Run Implementation with Pure Code Mode")
+    print("4. Test Read Tools Configuration")
+
+    # mode_choice = input("Enter choice (1-4, default: 3): ").strip()
+
+    # For testing purposes, we'll run the test first
+    # if mode_choice == "4":
+    #     print("Testing Read Tools Configuration...")
+
+    #     # Create a test workflow normally
+    #     test_workflow = CodeImplementationWorkflow()
+
+    #     # Create a mock code agent for testing
+    #     print("\n🧪 Testing with read tools DISABLED:")
+    #     test_agent_disabled = CodeImplementationAgent(None, enable_read_tools=False)
+    #     await test_agent_disabled.test_read_tools_configuration()
+
+    #     print("\n🧪 Testing with read tools ENABLED:")
+    #     test_agent_enabled = CodeImplementationAgent(None, enable_read_tools=True)
+    #     await test_agent_enabled.test_read_tools_configuration()
+
+    #     print("✅ Read tools configuration testing completed!")
+    #     return
+
+    # print("Running Code Reference Indexer Integration Test...")
+
+    test_success = True
+    if test_success:
+        print("\n" + "=" * 60)
+        print("🎉 UNIFIED Code Reference Indexer Integration Test PASSED!")
+        print("🔧 Three-step process successfully merged into ONE tool")
+        print("=" * 60)
+
+        # Ask if user wants to continue with actual workflow
+        print("\nContinuing with workflow execution...")
+
+        plan_file = "/Users/lizongwei/Reasearch/DeepCode_Base/DeepCode/deepcode_lab/papers/1/initial_plan.txt"
+        # plan_file = "/data2/bjdwhzzh/project-hku/Code-Agent2.0/Code-Agent/deepcode-mcp/agent_folders/papers/1/initial_plan.txt"
+        target_directory = (
+            "/Users/lizongwei/Reasearch/DeepCode_Base/DeepCode/deepcode_lab/papers/1/"
+        )
+        print("Implementation Mode Selection:")
+        print("1. Pure Code Implementation Mode (Recommended)")
+        print("2. Iterative Implementation Mode")
+
+        pure_code_mode = True
+        mode_name = "Pure Code Implementation Mode with Memory Agent Architecture + Code Reference Indexer"
+        print(f"Using: {mode_name}")
+
+        # Configure read tools - modify this parameter to enable/disable read tools
+        enable_read_tools = (
+            True  # Set to False to disable read_file and read_code_mem tools
+        )
+        read_tools_status = "ENABLED" if enable_read_tools else "DISABLED"
+        print(f"🔧 Read tools (read_file, read_code_mem): {read_tools_status}")
+
+        # NOTE: To test without read tools, change the line above to:
+        # enable_read_tools = False
+
+        result = await workflow.run_workflow(
+            plan_file,
+            target_directory=target_directory,
+            pure_code_mode=pure_code_mode,
+            enable_read_tools=enable_read_tools,
+        )
+
+        print("=" * 60)
+        print("Workflow Execution Results:")
+        print(f"Status: {result['status']}")
+        print(f"Mode: {mode_name}")
+
+        if result["status"] == "success":
+            print(f"Code Directory: {result['code_directory']}")
+            print(f"MCP Architecture: {result.get('mcp_architecture', 'unknown')}")
+            print("Execution completed!")
+        else:
+            print(f"Error Message: {result['message']}")
+
+        print("=" * 60)
+        print(
+            "✅ Using Standard MCP Architecture with Memory Agent + Code Reference Indexer"
+        )
+
+    else:
+        print("\n" + "=" * 60)
+        print("❌ Code Reference Indexer Integration Test FAILED!")
+        print("Please check the configuration and try again.")
+        print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())