Merge branch 'Get'

Author: Rxiain

api/config.py

@@ -69,6 +69,10 @@ class APIConfig(BaseSettings):
     docker_builder_image: str = Field(default="pure-codeql-cpp:latest", description="Docker 构建镜像名称")
     prefer_local_cpp_build: bool = Field(default=True, description="C/C++ 项目优先尝试本地两步走构建，失败后再用Docker")
     local_build_prepare_timeout: int = Field(default=300, description="本地准备阶段（configure/cmake）超时时间(秒)")
+    
+    # 自动依赖安装配置
+    auto_install_dependencies: bool = Field(default=True, description="自动检测并安装缺失的C/C++构建依赖")
+    auto_install_max_retries: int = Field(default=5, description="自动安装依赖后的最大重试次数")
 
     class Config:
         env_prefix = "API_"

services/llm_service.py

@@ -22,6 +22,7 @@
 from config import get_chat_config, LLMConfig, get_resilient_llm_config, LLMRole
 from utils.logger import get_logger
 from services.agent_mcp_config import AgentMCPConfigService
+from utils.mcp_schema_fixer import fix_mcp_tools_schemas
 
 
 class APIErrorClassifier:
@@ -824,7 +825,7 @@ async def initialize(
         """
         logger = get_logger(__name__)
         self.llm = RetryableChatOpenAI(self.config, self.retry_tracker, event_callback)
-        
+
         # Store language for tools that need it
         self.language = language
 
@@ -846,7 +847,7 @@ async def initialize(
         # tree_sitter 和 language-server 都可能因为项目配置问题失败，但不应该阻止整个流程
         optional_servers = {"language-server", "tree_sitter"}
         failed_servers = []
-        
+
         for server_name, connection in mcp_servers.items():
             try:
                 if server_name == "tree_sitter":
@@ -878,7 +879,7 @@ async def initialize(
                         self._session_stack = None
                         self._mcp_sessions = {}
                     raise
-        
+
         if failed_servers:
             logger.info(f"ℹ️  跳过了 {len(failed_servers)} 个可选 MCP 服务器: {', '.join(failed_servers)}")
 
@@ -890,6 +891,12 @@ async def initialize(
             lsp_lookup_tool = LSPFunctionLookupTool(default_language=self.language or "java")
             self.tools.append(lsp_lookup_tool)
 
+        # Fix MCP tools schemas for Ubuntu compatibility
+        # 修复Ubuntu环境下MCP工具schema不完整的问题
+        # 在某些环境下，langchain-mcp-adapters返回的schema只有$schema字段，
+        # 缺少type和properties，导致DeepSeek等API拒绝
+        fix_mcp_tools_schemas(self.tools)
+
         # Wrap all tools with token limiting
         logger = get_logger(__name__)
         logger.info(f"正在包装 {len(self.tools)} 个工具（包含MCP工具和LSP查询工具）...")

utils/codeql.py

@@ -43,6 +43,12 @@ def resolve_codeql_database_root(path: str, language: Optional[str] = None) -> s
     如果给定路径本身包含 codeql-database.yml，则返回该路径。
     如果给定路径不包含，但其子目录（如 python/ 或 cpp/）包含，则返回子目录路径。
     如果指定了language，则优先查找名称匹配的子目录。
+    
+    支持的格式：
+    - {path}/codeql-database.yml (直接路径)
+    - {path}/{language}/codeql-database.yml (例如: db/cpp, db/python, db/java)
+    - {path}/db-{language}/codeql-database.yml (例如: db-java, db-cpp)
+    - {path}/db/{language}/codeql-database.yml (例如: projects/CVE-xxx/db/cpp)
     """
     if not path:
         return path
@@ -51,6 +57,7 @@ def resolve_codeql_database_root(path: str, language: Optional[str] = None) -> s
     if not db_path.exists():
         return path
 
+    # 如果路径本身就是数据库根目录
     if (db_path / "codeql-database.yml").exists():
         return str(db_path)
 
@@ -68,27 +75,41 @@ def resolve_codeql_database_root(path: str, language: Optional[str] = None) -> s
             target_lang = lang_map.get(lang_lower, lang_lower)
 
             # 尝试查找精确匹配的子目录或 db-{lang} 格式
+            # 优先级：直接子目录 > db-{lang} > db/{lang}
             candidates = [
-                db_path / target_lang,
-                db_path / f"db-{target_lang}",
-                db_path / f"db/{target_lang}"
+                db_path / target_lang,  # 例如: db_path/cpp
+                db_path / f"db-{target_lang}",  # 例如: db_path/db-cpp
+                db_path / "db" / target_lang,  # 例如: db_path/db/cpp
             ]
 
             for candidate in candidates:
                 if candidate.is_dir() and (candidate / "codeql-database.yml").exists():
                     return str(candidate)
+            
+            # 如果没找到，尝试在 db/{lang}/db-{lang} 这样的嵌套结构中查找
+            nested_candidate = db_path / "db" / target_lang / f"db-{target_lang}"
+            if nested_candidate.is_dir() and (nested_candidate / "codeql-database.yml").exists():
+                return str(nested_candidate)
 
         # 如果没指定语言或没找到特定语言目录，则遍历一级子目录
         for subdir in db_path.iterdir():
             if subdir.is_dir() and (subdir / "codeql-database.yml").exists():
                 return str(subdir)
-                
-        # 尝试深入一层 (例如 db/python/codeql-database.yml)
+        
+        # 尝试深入一层 (例如 db/python/codeql-database.yml 或 db/cpp/codeql-database.yml)
         db_subdir = db_path / "db"
         if db_subdir.is_dir():
+            # 先检查 db 下的直接子目录
             for subdir in db_subdir.iterdir():
-                 if subdir.is_dir() and (subdir / "codeql-database.yml").exists():
+                if subdir.is_dir() and (subdir / "codeql-database.yml").exists():
                     return str(subdir)
+            
+            # 再检查 db/{lang}/db-{lang} 这样的嵌套结构
+            for lang_subdir in db_subdir.iterdir():
+                if lang_subdir.is_dir():
+                    nested_db = lang_subdir / f"db-{lang_subdir.name}"
+                    if nested_db.is_dir() and (nested_db / "codeql-database.yml").exists():
+                        return str(nested_db)
 
     except Exception:
         pass
@@ -396,8 +417,9 @@ def run_simple_query(query_content: str, database_path: str, language: Optional[
         - results (List): 如果成功则包含解析结果，否则为空列表
         - result_file (str): 结果文件的路径
     """
-    # 在执行前验证数据库
-    is_valid, validation_error = validate_codeql_database(database_path)
+    # 在执行前验证数据库并解析真正的数据库路径
+    resolved_database_path = resolve_codeql_database_root(database_path, language)
+    is_valid, validation_error = validate_codeql_database(resolved_database_path, language)
     if not is_valid:
         return {
             'success': False,
@@ -432,6 +454,8 @@ def run_simple_query(query_content: str, database_path: str, language: Optional[
         with open(log_file, 'a', encoding='utf-8') as f:
             f.write(f"\n{'='*80}\n")
             f.write(f"[{log_timestamp}] 执行 codeql query run (简单查询)\n")
+            f.write(f"原始数据库路径: {database_path}\n")
+            f.write(f"解析后数据库路径: {resolved_database_path}\n")
             f.write(f"{'='*80}\n")
 
         start_time = time.time()
@@ -442,7 +466,7 @@ def run_simple_query(query_content: str, database_path: str, language: Optional[
             [
                 'codeql', 'query', 'run',
                 str(query_file),
-                '--database', database_path,
+                '--database', resolved_database_path,
                 f'--output={str(bqrs_path)}',
             ],
             stdout=subprocess.PIPE,
@@ -662,8 +686,9 @@ def execute_codeql_query(query_content: str, database_path: str, language: Optio
         - results (List): 如果成功则包含解析结果，否则为空列表
         - sarif_path (str): SARIF输出文件的路径
     """
-    # 在执行前验证数据库
-    is_valid, validation_error = validate_codeql_database(database_path)
+    # 在执行前验证数据库并解析真正的数据库路径
+    resolved_database_path = resolve_codeql_database_root(database_path, language)
+    is_valid, validation_error = validate_codeql_database(resolved_database_path, language)
     if not is_valid:
         return {
             'success': False,
@@ -672,9 +697,9 @@ def execute_codeql_query(query_content: str, database_path: str, language: Optio
             'sarif_path': None,
         }
 
-    # 如果指定了alert参数，执行简单查询
+    # 如果指定了alert参数，执行简单查询（使用解析后的路径）
     if alert == 'alert':
-        return run_simple_query(query_content, database_path, language, query_file)
+        return run_simple_query(query_content, resolved_database_path, language, query_file)
 
     sarif_path: Optional[Path] = None
     try:
@@ -703,6 +728,8 @@ def execute_codeql_query(query_content: str, database_path: str, language: Optio
         with open(log_file, 'a', encoding='utf-8') as f:
             f.write(f"\n{'='*80}\n")
             f.write(f"[{log_timestamp}] 执行 codeql database analyze\n")
+            f.write(f"原始数据库路径: {database_path}\n")
+            f.write(f"解析后数据库路径: {resolved_database_path}\n")
             f.write(f"{'='*80}\n")
 
         # 使用`codeql database analyze`执行查询，并使用SARIF v2.1.0输出，添加 --verbose 参数
@@ -711,7 +738,7 @@ def execute_codeql_query(query_content: str, database_path: str, language: Optio
             [
                 'codeql', 'database', 'analyze',
                 '--verbose',
-                database_path,
+                resolved_database_path,
                 str(query_file),
                 '--rerun',
                 '--format=sarifv2.1.0',
@@ -861,8 +888,9 @@ def run_query_and_decode_to_text(
         - output (str): 查询输出或错误消息
         - result_file (str): 结果文件路径
     """
-    # 在执行前验证数据库
-    is_valid, validation_error = validate_codeql_database(database_path)
+    # 在执行前验证数据库并解析真正的数据库路径
+    resolved_database_path = resolve_codeql_database_root(database_path, language)
+    is_valid, validation_error = validate_codeql_database(resolved_database_path, language)
     if not is_valid:
         return {
             'success': False,
@@ -885,6 +913,8 @@ def run_query_and_decode_to_text(
         with open(log_file, 'a', encoding='utf-8') as f:
             f.write(f"\n{'='*80}\n")
             f.write(f"[{log_timestamp}] 执行 codeql query run\n")
+            f.write(f"原始数据库路径: {database_path}\n")
+            f.write(f"解析后数据库路径: {resolved_database_path}\n")
             f.write(f"{'='*80}\n")
 
         # 执行 codeql query run，添加 --verbose 参数
@@ -894,7 +924,7 @@ def run_query_and_decode_to_text(
                 'codeql', 'query', 'run',
                 '--verbose',
                 str(query_file),
-                '--database', database_path,
+                '--database', resolved_database_path,
                 f'--output={str(bqrs_path)}',
             ],
             stdout=subprocess.PIPE,

utils/project_importer.py

@@ -15,6 +15,7 @@
 
 from api.config import get_config
 from utils.case import extract_cve_id
+from utils.dependency_installer import DependencyInstaller
 
 logger = logging.getLogger(__name__)
 
@@ -207,7 +208,12 @@ def _infer_case_id(input_dir: Path) -> Optional[str]:
             candidates.append(match)
 
     if not candidates:
-        return None
+        # 如果无法提取CVE ID，则使用目录名作为Case ID
+        # 替换非法字符以确保路径安全
+        import re
+        safe_name = re.sub(r'[^a-zA-Z0-9\-_]', '_', input_dir.name)
+        logger.info("未检测到CVE ID，使用目录名作为Case ID: %s", safe_name)
+        return safe_name
 
     candidates.sort()
     return candidates[0]
@@ -461,10 +467,18 @@ def _create_codeql_database(
         # 策略1：优先本地两步走构建（如果启用）
         if config.prefer_local_cpp_build and not config.use_docker_for_cpp:
             logger.info("=" * 60)
-            logger.info("策略1：尝试本地两步走构建")
+            logger.info("策略1：尝试本地两步走构建（支持自动依赖安装）")
             logger.info("=" * 60)
 
-            try:
+            # 创建依赖安装器（使用配置中的设置）
+            dep_installer = DependencyInstaller(
+                auto_install=config.auto_install_dependencies,
+                max_retries=config.auto_install_max_retries
+            )
+            log_path = db_path.parent / "codeql.log"
+            
+            def build_func():
+                """构建函数，供依赖安装器调用"""
                 # 清理旧数据库
                 if db_path.exists():
                     logger.info("清理旧数据库: %s", db_path)
@@ -494,52 +508,101 @@ def _create_codeql_database(
                     if build_plan.working_dir:
                         cmd.extend(["--working-dir", str(build_plan.working_dir)])
 
-                log_path = db_path.parent / "codeql.log"
                 _run_process(cmd, cwd=None, log_path=log_path)
 
                 # 验证数据库
                 src_zip = db_path / "src.zip"
                 if src_zip.exists() and src_zip.stat().st_size > 1024:
+                    return True
+                else:
+                    logger.warning("本地构建完成，但 src.zip 太小或不存在")
+                    raise RuntimeError("Local build produced invalid database")
+            
+            try:
+                # 使用自动依赖安装功能进行构建
+                success, error = dep_installer.try_build_with_auto_deps(
+                    build_func=build_func,
+                    log_path=log_path,
+                )
+                
+                if success:
                     logger.info("=" * 60)
                     logger.info("✅ 本地两步走构建成功！")
+                    if dep_installer.installed_packages:
+                        logger.info("📦 自动安装的依赖: %s", ", ".join(dep_installer.installed_packages))
                     logger.info("=" * 60)
                     return
                 else:
-                    logger.warning("本地构建完成，但 src.zip 太小或不存在")
-                    raise RuntimeError("Local build produced invalid database")
+                    raise RuntimeError(f"Local build failed after auto-installing dependencies: {error}")
 
             except Exception as e:
                 logger.warning("=" * 60)
                 logger.warning("⚠️  本地构建失败: %s", e)
                 logger.warning("=" * 60)
 
-                # 如果配置了 Docker，回退到 Docker autobuild
-                if config.docker_builder_image:
+                # 策略2：尝试 --build-mode=none（不编译，仅分析源码）
+                logger.info("=" * 60)
+                logger.info("策略2：尝试 --build-mode=none（仅分析源码，不编译）")
+                logger.info("=" * 60)
+                
+                try:
+                    # 清理失败的数据库
+                    if db_path.exists():
+                        _safe_rmtree(db_path)
+                    
+                    # 使用 --build-mode=none 创建数据库
+                    cmd = [
+                        "codeql",
+                        "database",
+                        "create",
+                        str(db_path),
+                        "--language",
+                        language,
+                        "--overwrite",
+                        "--build-mode=none",
+                        "--source-root",
+                        str(source_root),
+                    ]
+                    
+                    none_log_path = db_path.parent / "codeql_none_mode.log"
+                    _run_process(cmd, cwd=None, log_path=none_log_path)
+                    
                     logger.info("=" * 60)
-                    logger.info("策略2：回退到 Docker autobuild")
+                    logger.info("✅ --build-mode=none 创建数据库成功！")
+                    logger.info("⚠️  注意：未编译项目，分析结果可能不完整")
                     logger.info("=" * 60)
+                    return
 
-                    try:
-                        # 清理失败的数据库
-                        if db_path.exists():
-                            _safe_rmtree(db_path)
-                        
-                        _run_docker_build(
-                            source_root=source_root,
-                            db_path=db_path,
-                            image_name=config.docker_builder_image,
-                            build_plan=None  # Docker 内部会自动探测
-                        )
+                except Exception as none_error:
+                    logger.warning("--build-mode=none 也失败了: %s", none_error)
+                    
+                    # 策略3：如果配置了 Docker，回退到 Docker autobuild
+                    if config.docker_builder_image:
                         logger.info("=" * 60)
-                        logger.info("✅ Docker autobuild 构建成功！")
+                        logger.info("策略3：最后回退到 Docker autobuild")
                         logger.info("=" * 60)
-                        return
-                    except Exception as docker_error:
-                        logger.error("Docker autobuild 也失败了: %s", docker_error)
-                        raise RuntimeError(f"Both local and Docker builds failed. Local: {e}, Docker: {docker_error}")
-                else:
-                    # 没有 Docker 配置，直接失败
-                    raise RuntimeError(f"Local build failed and no Docker fallback configured: {e}")
+                        
+                        try:
+                            # 清理失败的数据库
+                            if db_path.exists():
+                                _safe_rmtree(db_path)
+                            
+                            _run_docker_build(
+                                source_root=source_root,
+                                db_path=db_path,
+                                image_name=config.docker_builder_image,
+                                build_plan=None  # Docker 内部会自动探测
+                            )
+                            logger.info("=" * 60)
+                            logger.info("✅ Docker autobuild 构建成功！")
+                            logger.info("=" * 60)
+                            return
+                        except Exception as docker_error:
+                            logger.error("Docker autobuild 也失败了: %s", docker_error)
+                            raise RuntimeError(f"All build strategies failed. Local: {e}, None mode: {none_error}, Docker: {docker_error}")
+                    else:
+                        # 没有 Docker 配置
+                        raise RuntimeError(f"Build failed. Local: {e}, None mode: {none_error}")
 
         # 策略2：直接使用 Docker 构建（如果强制启用）
         elif config.use_docker_for_cpp: