fix(semantic_search): Fix core defect - Now searches both memory and codebase index

Critical fixes:
- Database: Add getFileIndexForVectorSearch() method to query file_index table
- Search Logic: Modified handleSemanticSearch() to query both contexts and file_index
- Data Conversion: Convert file_index records to Context-compatible format
- Priority Optimization: Code file quality_score increased from 0.8 to 0.95
- Project Detection: Enhanced path detection for multi-project scenarios
- Smart Warnings: Detect multiple active projects, warn to specify project_path

Testing:
- Created test-semantic-search.js validating the fix
- Verified development memory + codebase index simultaneous search
- Confirmed code file priority for "how to implement" queries
- TypeScript compilation passes with no errors

Version: 2.4.9 -> 2.5.0

Author: JochenYang

CHANGELOG.md

@@ -5,6 +5,52 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.0] - 2025-12-16
+
+### Fixed
+
+- **Critical: semantic_search Core Defect Fixed**: Previously, semantic_search only searched development memory (contexts table) while completely ignoring ContextEngine-indexed code files (file_index table), causing the "full project understanding" feature to fail
+  - **Database Layer**: Added `getFileIndexForVectorSearch()` method to query file_index table
+  - **Search Logic**: Modified `handleSemanticSearch()` to query both contexts and file_index
+  - **Data Conversion**: Convert file_index records to Context-compatible format
+  - **Priority Optimization**: Code file quality score increased from 0.8 to 0.95
+  - **Project Detection**: Improved path detection logic for multi-project scenarios
+  - **Smart Warnings**: Detect multiple active projects and warn users to explicitly specify project_path
+
+### Added
+
+- **Enhanced Project Detection**: Multi-factor scoring system for project path detection
+  - Existing projects get +10 points
+  - Recently accessed projects get additional +20 points
+  - Projects with .git directory get +5 points
+  - Detailed logging for troubleshooting
+
+- **Multi-Project Warnings**: Smart detection and user guidance
+  - Detects multiple recently active projects (within 7 days)
+  - Warns when operations might be recorded to non-most-recent project
+  - Provides clear usage recommendations
+
+### Changed
+
+- **Search Result Ranking**: Code files now prioritized for "how to implement" queries
+  - Code files: quality_score 0.95 (was 0.8)
+  - Development memory: quality_score 0.9
+  - Combined with QueryEnhancer file type weights for optimal results
+
+### Impact
+
+- **For Users**: Can now perform true "full project understanding" queries in natural language
+- **For Developers**: Code discovery and project understanding significantly improved
+- **Multi-Project Support**: Better isolation and warnings for multi-project development scenarios
+- **Performance**: Unified search across memory and codebase without performance degradation
+
+### Testing
+
+- Created comprehensive test script `test-semantic-search.js` validating the fix
+- Verified development memory + codebase index simultaneous search
+- Confirmed code file priority for "implementation" queries
+- TypeScript compilation passes with no errors
+
 ## [2.4.9] - 2025-12-16
 
 ### Added

package.json

@@ -1,6 +1,6 @@
 {
   "name": "devmind-mcp",
-  "version": "2.4.9",
+  "version": "2.5.0",
   "description": "DevMind MCP - AI Assistant Memory System - Pure MCP Tool",
   "main": "dist/index.js",
   "type": "module",

src/database.ts

@@ -990,6 +990,69 @@ export class DatabaseManager {
     return stmt.all(...params) as Context[];
   }
 
+  /**
+   * 获取用于向量搜索的代码库索引文件
+   */
+  getFileIndexForVectorSearch(
+    projectId?: string,
+    sessionId?: string
+  ): Array<{
+    id: string;
+    project_id: string;
+    session_id: string;
+    file_path: string;
+    relative_path: string;
+    content: string;
+    language?: string;
+    file_type?: string;
+    size: number;
+    modified_time: string;
+    indexed_at: string;
+    hash: string;
+    tags: string;
+    metadata: string;
+  }> {
+    let sql = `
+      SELECT fi.* FROM file_index fi
+    `;
+    const params: any[] = [];
+    const conditions: string[] = [];
+
+    if (projectId) {
+      conditions.push("fi.project_id = ?");
+      params.push(projectId);
+    }
+
+    if (sessionId) {
+      conditions.push("fi.session_id = ?");
+      params.push(sessionId);
+    }
+
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+
+    sql += ` ORDER BY fi.modified_time DESC`;
+
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params) as Array<{
+      id: string;
+      project_id: string;
+      session_id: string;
+      file_path: string;
+      relative_path: string;
+      content: string;
+      language?: string;
+      file_type?: string;
+      size: number;
+      modified_time: string;
+      indexed_at: string;
+      hash: string;
+      tags: string;
+      metadata: string;
+    }>;
+  }
+
   getEmbeddingStats(): {
     total: number;
     withEmbedding: number;

src/mcp-server.ts

@@ -1535,6 +1535,48 @@ Note: This only deletes the file index, not your development memory contexts.`,
         }
       }
 
+      // === 多项目场景验证 (v2.5.0) ===
+      if (inferredProjectPath) {
+        try {
+          // 获取所有项目进行对比
+          const allProjects = this.db.getAllProjects();
+          if (allProjects.length > 1) {
+            const currentProject = allProjects.find(
+              (p: any) => p.path === inferredProjectPath
+            );
+            if (currentProject) {
+              // 检查是否有多个最近活跃的项目
+              const recentProjects = allProjects
+                .filter((p: any) => {
+                  const lastAccess = new Date(p.last_accessed || 0);
+                  const daysSince = (Date.now() - lastAccess.getTime()) / (1000 * 60 * 60 * 24);
+                  return daysSince < 7; // 最近7天访问过的项目
+                })
+                .sort((a: any, b: any) => {
+                  const aTime = new Date(a.last_accessed || 0).getTime();
+                  const bTime = new Date(b.last_accessed || 0).getTime();
+                  return bTime - aTime; // 按访问时间倒序
+                });
+
+              if (recentProjects.length > 1 && currentProject.id !== recentProjects[0].id) {
+                console.warn(
+                  `[DevMind] ⚠️ 多项目检测: 检测到 ${recentProjects.length} 个最近活跃项目，当前操作将记录到: ${currentProject.name}`
+                );
+                console.warn(
+                  `[DevMind] 💡 建议: 在多项目开发时，请在 record_context 中明确指定 project_path 参数以避免混淆`
+                );
+                autoSessionMeta.multi_project_warning = true;
+                autoSessionMeta.current_project = currentProject.name;
+                autoSessionMeta.recent_projects = recentProjects.map((p: any) => p.name);
+              }
+            }
+          }
+        } catch (error) {
+          // 静默失败，不影响正常流程
+          console.warn("[DevMind] Multi-project validation failed:", error);
+        }
+      }
+
       if (!sessionId && inferredProjectPath) {
         // 尝试获取活跃会话
         const currentSessionId = await this.sessionManager.getCurrentSession(
@@ -2932,24 +2974,51 @@ Note: This only deletes the file index, not your development memory contexts.`,
         console.error("[AI Enhancement] Query enhancement failed:", error);
       }
 
-      // 获取用于搜索的contexts
+      // 获取用于搜索的contexts（开发记忆）
       const allContexts = this.db.getContextsForVectorSearch(
         projectId,
         args.session_id
       );
 
-      if (allContexts.length === 0) {
+      // 获取代码库索引文件
+      const allFileIndex = this.db.getFileIndexForVectorSearch(
+        projectId,
+        args.session_id
+      );
+
+      // 转换 file_index 为兼容格式以便搜索
+      const fileIndexAsContexts = allFileIndex.map((file) => ({
+        id: file.id,
+        session_id: file.session_id,
+        project_id: file.project_id,
+        content: file.content,
+        type: "code" as ContextType, // 使用 ContextType.CODE 表示代码文件
+        tags: file.tags,
+        file_path: file.file_path,
+        created_at: file.indexed_at,
+        updated_at: file.modified_time,
+        quality_score: 0.95, // 提升代码文件优先级，确保"如何实现"类查询优先返回代码
+        embedding_text: undefined, // 文件没有预生成的embedding
+        metadata: file.metadata,
+      }));
+
+      // 合并开发记忆和代码库索引
+      const allSearchData = [...allContexts, ...fileIndexAsContexts];
+
+      if (allSearchData.length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: "No contexts with embeddings found. Try running generate_embeddings first.",
+              text: "No contexts or codebase files found. Try running generate_embeddings first or index your codebase.",
             },
           ],
           isError: false,
           _meta: {
             query: args.query,
             results: [],
+            contexts_count: 0,
+            files_count: 0,
           },
         };
       }
@@ -2958,7 +3027,7 @@ Note: This only deletes the file index, not your development memory contexts.`,
       const searchParams = {
         query: args.query,
         use_semantic_search: true,
-        limit: args.limit || 10,
+        limit: args.limit || 20, // 增加默认限制以包含更多结果
         similarity_threshold:
           args.similarity_threshold ||
           this.config.vector_search?.similarity_threshold ||
@@ -2967,18 +3036,18 @@ Note: This only deletes the file index, not your development memory contexts.`,
           args.hybrid_weight || this.config.vector_search?.hybrid_weight || 0.7,
       };
 
-      // 获取关键词搜索结果作为基线
+      // 获取关键词搜索结果作为基线（仅针对开发记忆）
       const keywordResults = this.db.searchContexts(
         enhancedQuery,
         projectId,
         searchParams.limit
       );
 
-      // 执行混合搜索
+      // 执行混合搜索（搜索所有数据：记忆 + 代码库）
       let results = await this.vectorSearch.hybridSearch(
         enhancedQuery,
         keywordResults,
-        allContexts,
+        allSearchData,
         searchParams
       );
 
@@ -3197,10 +3266,13 @@ Note: This only deletes the file index, not your development memory contexts.`,
           query: args.query,
           enhanced_query: enhancedQuery,
           total_contexts_searched: allContexts.length,
+          total_files_searched: allFileIndex.length,
           results_count: formattedResults.length,
           results: formattedResults,
           search_params: searchParams,
           query_enhancement: queryEnhancementMeta,
+          contexts_count: allContexts.length,
+          files_count: allFileIndex.length,
         },
       };
     } catch (error) {

src/session-manager.ts

@@ -212,27 +212,68 @@ export class SessionManager {
    * @returns 检测到的项目路径或undefined
    */
   private autoDetectProjectPath(): string | undefined {
-    // 优先级顺序（参考v2.1.15实现）
+    // 优先级顺序（改进版 v2.5.0）
     const potentialPaths = [
       process.env.INIT_CWD,      // npm/npx初始目录
       process.env.PWD,            // Unix工作目录
       process.env.CD,             // Windows当前目录
       process.cwd(),              // Node.js当前目录
     ].filter(Boolean) as string[];
 
-    // 找到第一个存在的目录
+    // 多项目检测：尝试找到最匹配的项目
+    let bestMatch: string | undefined;
+    let maxScore = 0;
+
     for (const dir of potentialPaths) {
       try {
-        if (existsSync(dir)) {
-          return normalizeProjectPath(dir);
+        if (!existsSync(dir)) continue;
+
+        const projectRoot = findProjectRoot(dir);
+        const normalizedPath = normalizeProjectPath(projectRoot);
+
+        // 计算匹配分数
+        let score = 0;
+        const project = this.db.getProjectByPath(normalizedPath);
+
+        // 如果项目已存在，加分
+        if (project) {
+          score += 10;
+          // 如果是最近访问的项目，额外加分
+          if (this.lastAccessedProject === normalizedPath) {
+            score += 20;
+          }
+        }
+
+        // 如果目录有 .git，加分
+        try {
+          if (existsSync(`${projectRoot}/.git`)) {
+            score += 5;
+          }
+        } catch (e) {
+          // 忽略错误
+        }
+
+        console.log(`[SessionManager] Project detection score for ${normalizedPath}: ${score}`);
+
+        if (score > maxScore) {
+          maxScore = score;
+          bestMatch = normalizedPath;
         }
       } catch (error) {
         // 跳过无法访问的目录
         continue;
       }
     }
 
-    return undefined;
+    if (bestMatch) {
+      console.log(`[SessionManager] Auto-detected project path (score: ${maxScore}): ${bestMatch}`);
+      return bestMatch;
+    }
+
+    // 兜底：返回规范化后的当前目录
+    const fallbackDir = normalizeProjectPath(process.cwd());
+    console.warn(`[SessionManager] No suitable project found, using fallback: ${fallbackDir}`);
+    return fallbackDir;
   }
 
   /**