new version update

Author: Zongwei9888

cli/cli_interface.py

@@ -39,7 +39,7 @@ def __init__(self):
         self.uploaded_file = None
         self.is_running = True
         self.processing_history = []
-        self.enable_indexing = True  # Default configuration
+        self.enable_indexing = False  # Default configuration (matching UI: fast mode by default)
 
         # Load segmentation config from the same source as UI
         self._load_segmentation_config()

cli/main_cli.py

@@ -214,15 +214,17 @@ async def main():
         # 创建CLI应用
         app = CLIApp()
 
-        # 设置配置
+        # 设置配置 - 默认禁用索引功能以加快处理速度
         if args.optimized:
             app.cli.enable_indexing = False
             print(
                 f"\n{Colors.YELLOW}⚡ Optimized mode enabled - indexing disabled{Colors.ENDC}"
             )
         else:
+            # 默认也禁用索引功能
+            app.cli.enable_indexing = False
             print(
-                f"\n{Colors.GREEN}🧠 Comprehensive mode enabled - full intelligence analysis{Colors.ENDC}"
+                f"\n{Colors.YELLOW}⚡ Fast mode enabled - indexing disabled by default{Colors.ENDC}"
             )
 
         # Configure document segmentation settings
@@ -248,7 +250,9 @@ async def main():
                 if not os.path.exists(args.file):
                     print(f"{Colors.FAIL}❌ File not found: {args.file}{Colors.ENDC}")
                     sys.exit(1)
-                success = await run_direct_processing(app, args.file, "file")
+                # 使用 file:// 前缀保持与交互模式一致，确保文件被复制而非移动
+                file_url = f"file://{os.path.abspath(args.file)}"
+                success = await run_direct_processing(app, file_url, "file")
             elif args.url:
                 success = await run_direct_processing(app, args.url, "url")
             elif args.chat:

cli/workflows/cli_workflow_adapter.py

@@ -4,6 +4,14 @@
 
 This adapter provides CLI-optimized interface to the latest agent orchestration engine,
 with enhanced progress reporting, error handling, and CLI-specific optimizations.
+
+Version: 2.0 (Updated to match UI version)
+Changes:
+- Default enable_indexing=False for faster processing (matching UI defaults)
+- Mode-aware progress callback with detailed stage mapping
+- Chat pipeline now accepts enable_indexing parameter
+- Improved error handling and resource management
+- Enhanced progress display for different modes (fast/comprehensive/chat)
 """
 
 import os
@@ -36,7 +44,7 @@ def __init__(self, cli_interface=None):
 
     async def initialize_mcp_app(self) -> Dict[str, Any]:
         """
-        Initialize MCP application for CLI usage.
+        Initialize MCP application for CLI usage (improved version matching UI).
 
         Returns:
             dict: Initialization result
@@ -47,7 +55,7 @@ async def initialize_mcp_app(self) -> Dict[str, Any]:
                     "🚀 Initializing Agent Orchestration Engine", 2.0
                 )
 
-            # Initialize MCP application
+            # Initialize MCP application using async context manager (matching UI pattern)
             self.app = MCPApp(name="cli_agent_orchestration")
             self.app_context = self.app.run()
             agent_app = await self.app_context.__aenter__()
@@ -56,8 +64,6 @@ async def initialize_mcp_app(self) -> Dict[str, Any]:
             self.context = agent_app.context
 
             # Configure filesystem access
-            import os
-
             self.context.config.mcp.servers["filesystem"].args.extend([os.getcwd()])
 
             if self.cli_interface:
@@ -93,48 +99,75 @@ async def cleanup_mcp_app(self):
                         f"⚠️ Cleanup warning: {str(e)}", "warning"
                     )
 
-    def create_cli_progress_callback(self) -> Callable:
+    def create_cli_progress_callback(self, enable_indexing: bool = True) -> Callable:
         """
-        Create CLI-optimized progress callback function.
+        Create CLI-optimized progress callback function with mode-aware stage mapping.
+        
+        This matches the UI version's detailed progress mapping logic.
+
+        Args:
+            enable_indexing: Whether indexing is enabled (affects stage mapping)
 
         Returns:
             Callable: Progress callback function
         """
 
         def progress_callback(progress: int, message: str):
             if self.cli_interface:
-                # Map progress to CLI stages
-                if progress <= 10:
-                    self.cli_interface.display_processing_stages(1)
-                elif progress <= 25:
-                    self.cli_interface.display_processing_stages(2)
-                elif progress <= 40:
-                    self.cli_interface.display_processing_stages(3)
-                elif progress <= 50:
-                    self.cli_interface.display_processing_stages(4)
-                elif progress <= 60:
-                    self.cli_interface.display_processing_stages(5)
-                elif progress <= 70:
-                    self.cli_interface.display_processing_stages(6)
-                elif progress <= 85:
-                    self.cli_interface.display_processing_stages(7)
+                # Mode-aware stage mapping (matching UI version logic)
+                if enable_indexing:
+                    # Full workflow mapping: Initialize -> Analyze -> Download -> Plan -> References -> Repos -> Index -> Implement
+                    if progress <= 5:
+                        stage = 0  # Initialize
+                    elif progress <= 10:
+                        stage = 1  # Analyze
+                    elif progress <= 25:
+                        stage = 2  # Download
+                    elif progress <= 40:
+                        stage = 3  # Plan
+                    elif progress <= 50:
+                        stage = 4  # References
+                    elif progress <= 60:
+                        stage = 5  # Repos
+                    elif progress <= 70:
+                        stage = 6  # Index
+                    elif progress <= 85:
+                        stage = 7  # Implement
+                    else:
+                        stage = 8  # Complete
                 else:
-                    self.cli_interface.display_processing_stages(8)
+                    # Fast mode mapping: Initialize -> Analyze -> Download -> Plan -> Implement
+                    if progress <= 5:
+                        stage = 0  # Initialize
+                    elif progress <= 10:
+                        stage = 1  # Analyze
+                    elif progress <= 25:
+                        stage = 2  # Download
+                    elif progress <= 40:
+                        stage = 3  # Plan
+                    elif progress <= 85:
+                        stage = 4  # Implement (skip References, Repos, Index)
+                    else:
+                        stage = 4  # Complete
+                
+                self.cli_interface.display_processing_stages(stage, enable_indexing)
 
                 # Display status message
                 self.cli_interface.print_status(message, "processing")
 
         return progress_callback
 
     async def execute_full_pipeline(
-        self, input_source: str, enable_indexing: bool = True
+        self, input_source: str, enable_indexing: bool = False
     ) -> Dict[str, Any]:
         """
         Execute the complete intelligent multi-agent research orchestration pipeline.
+        
+        Updated to match UI version: default enable_indexing=False for faster processing.
 
         Args:
             input_source: Research input source (file path, URL, or preprocessed analysis)
-            enable_indexing: Whether to enable advanced intelligence analysis
+            enable_indexing: Whether to enable advanced intelligence analysis (default: False)
 
         Returns:
             dict: Comprehensive pipeline execution result
@@ -145,16 +178,19 @@ async def execute_full_pipeline(
                 execute_multi_agent_research_pipeline,
             )
 
-            # Create CLI progress callback
-            progress_callback = self.create_cli_progress_callback()
+            # Create CLI progress callback with mode awareness
+            progress_callback = self.create_cli_progress_callback(enable_indexing)
 
             # Display pipeline start
             if self.cli_interface:
-                mode = "comprehensive" if enable_indexing else "optimized"
+                if enable_indexing:
+                    mode_msg = "🧠 comprehensive (with indexing)"
+                else:
+                    mode_msg = "⚡ fast (indexing disabled)"
                 self.cli_interface.print_status(
-                    f"🚀 Starting {mode} agent orchestration pipeline...", "processing"
+                    f"🚀 Starting {mode_msg} agent orchestration pipeline...", "processing"
                 )
-                self.cli_interface.display_processing_stages(0)
+                self.cli_interface.display_processing_stages(0, enable_indexing)
 
             # Execute the pipeline
             result = await execute_multi_agent_research_pipeline(
@@ -166,7 +202,8 @@ async def execute_full_pipeline(
 
             # Display completion
             if self.cli_interface:
-                self.cli_interface.display_processing_stages(8)
+                final_stage = 8 if enable_indexing else 4
+                self.cli_interface.display_processing_stages(final_stage, enable_indexing)
                 self.cli_interface.print_status(
                     "🎉 Agent orchestration pipeline completed successfully!",
                     "complete",
@@ -189,12 +226,15 @@ async def execute_full_pipeline(
                 "pipeline_mode": "comprehensive" if enable_indexing else "optimized",
             }
 
-    async def execute_chat_pipeline(self, user_input: str) -> Dict[str, Any]:
+    async def execute_chat_pipeline(self, user_input: str, enable_indexing: bool = False) -> Dict[str, Any]:
         """
         Execute the chat-based planning and implementation pipeline.
+        
+        Updated to match UI version: accepts enable_indexing parameter.
 
         Args:
             user_input: User's coding requirements and description
+            enable_indexing: Whether to enable indexing for enhanced code understanding (default: False)
 
         Returns:
             dict: Chat pipeline execution result
@@ -208,51 +248,42 @@ async def execute_chat_pipeline(self, user_input: str) -> Dict[str, Any]:
             # Create CLI progress callback for chat mode
             def chat_progress_callback(progress: int, message: str):
                 if self.cli_interface:
-                    # Map progress to CLI stages for chat mode
+                    # Map progress to CLI stages for chat mode (matching UI logic)
                     if progress <= 5:
-                        self.cli_interface.display_processing_stages(
-                            0, chat_mode=True
-                        )  # Initialize
+                        stage = 0  # Initialize
                     elif progress <= 30:
-                        self.cli_interface.display_processing_stages(
-                            1, chat_mode=True
-                        )  # Planning
+                        stage = 1  # Planning
                     elif progress <= 50:
-                        self.cli_interface.display_processing_stages(
-                            2, chat_mode=True
-                        )  # Setup
+                        stage = 2  # Setup
                     elif progress <= 70:
-                        self.cli_interface.display_processing_stages(
-                            3, chat_mode=True
-                        )  # Save Plan
+                        stage = 3  # Save Plan
                     else:
-                        self.cli_interface.display_processing_stages(
-                            4, chat_mode=True
-                        )  # Implement
+                        stage = 4  # Implement
+                    
+                    self.cli_interface.display_processing_stages(stage, chat_mode=True)
 
                     # Display status message
                     self.cli_interface.print_status(message, "processing")
 
             # Display pipeline start
             if self.cli_interface:
+                indexing_note = " (with indexing)" if enable_indexing else " (fast mode)"
                 self.cli_interface.print_status(
-                    "🚀 Starting chat-based planning pipeline...", "processing"
+                    f"🚀 Starting chat-based planning pipeline{indexing_note}...", "processing"
                 )
                 self.cli_interface.display_processing_stages(0, chat_mode=True)
 
-            # Execute the chat pipeline with indexing enabled for enhanced code understanding
+            # Execute the chat pipeline with configurable indexing
             result = await execute_chat_based_planning_pipeline(
                 user_input=user_input,
                 logger=self.logger,
                 progress_callback=chat_progress_callback,
-                enable_indexing=True,  # Enable indexing for better code implementation
+                enable_indexing=enable_indexing,  # Pass through enable_indexing parameter
             )
 
             # Display completion
             if self.cli_interface:
-                self.cli_interface.display_processing_stages(
-                    4, chat_mode=True
-                )  # Final stage for chat mode
+                self.cli_interface.display_processing_stages(4, chat_mode=True)
                 self.cli_interface.print_status(
                     "🎉 Chat-based planning pipeline completed successfully!",
                     "complete",
@@ -268,17 +299,18 @@ def chat_progress_callback(progress: int, message: str):
             return {"status": "error", "error": error_msg, "pipeline_mode": "chat"}
 
     async def process_input_with_orchestration(
-        self, input_source: str, input_type: str, enable_indexing: bool = True
+        self, input_source: str, input_type: str, enable_indexing: bool = False
     ) -> Dict[str, Any]:
         """
         Process input using the intelligent agent orchestration engine.
-
+        
         This is the main CLI interface to the latest agent orchestration capabilities.
+        Updated to match UI version: default enable_indexing=False.
 
         Args:
-            input_source: Input source (file path or URL)
-            input_type: Type of input ('file' or 'url')
-            enable_indexing: Whether to enable advanced intelligence analysis
+            input_source: Input source (file path, URL, or chat input)
+            input_type: Type of input ('file', 'url', or 'chat')
+            enable_indexing: Whether to enable advanced intelligence analysis (default: False)
 
         Returns:
             dict: Processing result with status and details
@@ -301,7 +333,10 @@ async def process_input_with_orchestration(
             # Execute appropriate pipeline based on input type
             if input_type == "chat":
                 # Use chat-based planning pipeline for user requirements
-                pipeline_result = await self.execute_chat_pipeline(input_source)
+                # Pass enable_indexing to chat pipeline as well
+                pipeline_result = await self.execute_chat_pipeline(
+                    input_source, enable_indexing=enable_indexing
+                )
             else:
                 # Use traditional multi-agent research pipeline for files/URLs
                 pipeline_result = await self.execute_full_pipeline(

mcp_agent.config.yaml

@@ -3,7 +3,7 @@ anthropic: null
 default_search_server: brave
 document_segmentation:
   enabled: true
-  size_threshold_chars: 3000
+  size_threshold_chars: 50000
 execution_engine: asyncio
 logger:
   level: info
@@ -25,12 +25,35 @@ mcp:
         BOCHA_API_KEY: ''
         PYTHONPATH: .
     brave:
+      # macos and linux should use this
+      # args:
+      # - -y
+      # - '@modelcontextprotocol/server-brave-search'
+      # command: npx
+
+      # windows should use this
       args:
-      - -y
-      - '@modelcontextprotocol/server-brave-search'
-      command: npx
+      # please use the correct path for your system
+      - C:/Users/LEGION/AppData/Roaming/npm/node_modules/@modelcontextprotocol/server-brave-search/dist/index.js
+      command: node
       env:
         BRAVE_API_KEY: ''
+    filesystem:
+      # macos and linux should use this
+      # args:
+      # - -y
+      # - '@modelcontextprotocol/server-filesystem'
+      # - .
+      # command: npx
+
+      # windows should use this
+      args:
+      # please use the correct path for your system
+      - C:/Users/LEGION/AppData/Roaming/npm/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js
+      - .
+      command: node
+
+ 
     code-implementation:
       args:
       - tools/code_implementation_server.py
@@ -71,12 +94,6 @@ mcp:
       command: python
       env:
         PYTHONPATH: .
-    filesystem:
-      args:
-      - -y
-      - '@modelcontextprotocol/server-filesystem'
-      - .
-      command: npx
     github-downloader:
       args:
       - tools/git_command.py

mcp_agent.secrets.yaml

@@ -5,5 +5,5 @@ openai:
 
 
 
-anthropic:
-  api_key: ""
+# anthropic:
+#   api_key: ""