Merge branch 'master' into 'opensource'

sync v1.0.303

See merge request ai_native/DeepVCode/DeepVcodeClient!333

Author: JerryliDe

packages/core/src/skills/loaders/marketplace-loader.ts

@@ -266,10 +266,14 @@ export class MarketplaceLoader implements IPluginLoader {
       }
     }
 
-    // 3. 如果没有显式定义组件，且 strict !== false，则自动发现
-    const isStrictMode = pluginDef.strict !== false;
-
-    if (components.length === 0 || !isStrictMode) {
+    // 3. 自动发现组件
+    // strict 字段语义：
+    //   - undefined (默认): 总是自动发现并合并，确保发现所有组件
+    //   - false: 总是自动发现并合并（显式声明）
+    //   - true: 只使用显式定义的组件，不自动发现
+    const shouldAutoDiscover = pluginDef.strict !== true;
+
+    if (shouldAutoDiscover) {
       // 自动发现标准目录
       // 按照标准目录和常见第三方工具目录进行自动发现
       const discoveryTasks = [
@@ -283,11 +287,32 @@ export class MarketplaceLoader implements IPluginLoader {
         { name: '.roo/commands', type: ComponentType.COMMAND },
       ];
 
+      const discoveredComponents: UnifiedComponent[] = [];
       for (const task of discoveryTasks) {
-        components.push(...await this.scanComponents(
+        discoveredComponents.push(...await this.scanComponents(
           pluginDir, task.name, task.type, id, marketplaceId
         ));
       }
+
+      // 合并显式定义的组件和自动发现的组件（去重）
+      // 显式定义的组件优先（保持在前面），然后添加新发现的组件
+      const existingIds = new Set(components.map(c => c.id));
+      let addedCount = 0;
+      for (const discovered of discoveredComponents) {
+        if (!existingIds.has(discovered.id)) {
+          components.push(discovered);
+          existingIds.add(discovered.id);
+          addedCount++;
+        }
+      }
+
+      // Debug logging for skill discovery
+      if (process.env.DEBUG_SKILLS) {
+        console.log(`[MarketplaceLoader] Plugin ${id}:`);
+        console.log(`  - Explicit components: ${components.length - addedCount}`);
+        console.log(`  - Auto-discovered: ${addedCount}`);
+        console.log(`  - Total: ${components.length}`);
+      }
     }
 
     // 4. 构建 UnifiedPlugin

packages/core/src/tools/use-skill.test.ts

@@ -251,4 +251,146 @@ describe('UseSkillTool', () => {
       expect(result).toBe(false);
     });
   });
+
+  describe('skill name matching', () => {
+    it('should match skill by exact name (case-insensitive)', async () => {
+      const mockSkill = {
+        id: 'marketplace:plugin:pptx',
+        name: 'pptx',
+        description: 'Test skill',
+        pluginId: 'marketplace:plugin',
+        marketplaceId: 'marketplace',
+        path: '/mock/path',
+        skillFilePath: '/mock/path/SKILL.md',
+        metadata: { name: 'pptx' },
+        enabled: true,
+        loadLevel: SkillLoadLevel.RESOURCES,
+        scripts: [],
+      };
+
+      mockLoaderInstance = {
+        loadEnabledSkills: () => [mockSkill],
+      };
+      mockInjectorInstance = {
+        loadSkillLevel2: () => '# Test\n\nTest content',
+      };
+
+      // Test case-insensitive matching
+      const result1 = await useSkillTool.execute({ skillName: 'pptx' }, mockAbortSignal);
+      expect(result1.returnDisplay).toContain('✅ Loaded skill');
+
+      const result2 = await useSkillTool.execute({ skillName: 'PPTX' }, mockAbortSignal);
+      expect(result2.returnDisplay).toContain('✅ Loaded skill');
+
+      const result3 = await useSkillTool.execute({ skillName: 'PpTx' }, mockAbortSignal);
+      expect(result3.returnDisplay).toContain('✅ Loaded skill');
+    });
+
+    it('should match skill by ID suffix', async () => {
+      const mockSkill = {
+        id: 'marketplace:plugin:my-skill',
+        name: 'my-skill',
+        description: 'Test skill',
+        pluginId: 'marketplace:plugin',
+        marketplaceId: 'marketplace',
+        path: '/mock/path',
+        skillFilePath: '/mock/path/SKILL.md',
+        metadata: { name: 'my-skill' },
+        enabled: true,
+        loadLevel: SkillLoadLevel.RESOURCES,
+        scripts: [],
+      };
+
+      mockLoaderInstance = {
+        loadEnabledSkills: () => [mockSkill],
+      };
+      mockInjectorInstance = {
+        loadSkillLevel2: () => '# Test\n\nTest content',
+      };
+
+      // Should match by just the skill name
+      const result = await useSkillTool.execute({ skillName: 'my-skill' }, mockAbortSignal);
+      expect(result.returnDisplay).toContain('✅ Loaded skill');
+    });
+
+    it('should match skill by full ID', async () => {
+      const mockSkill = {
+        id: 'marketplace:plugin:my-skill',
+        name: 'my-skill',
+        description: 'Test skill',
+        pluginId: 'marketplace:plugin',
+        marketplaceId: 'marketplace',
+        path: '/mock/path',
+        skillFilePath: '/mock/path/SKILL.md',
+        metadata: { name: 'my-skill' },
+        enabled: true,
+        loadLevel: SkillLoadLevel.RESOURCES,
+        scripts: [],
+      };
+
+      mockLoaderInstance = {
+        loadEnabledSkills: () => [mockSkill],
+      };
+      mockInjectorInstance = {
+        loadSkillLevel2: () => '# Test\n\nTest content',
+      };
+
+      // Should match by full ID
+      const result = await useSkillTool.execute(
+        { skillName: 'marketplace:plugin:my-skill' },
+        mockAbortSignal
+      );
+      expect(result.returnDisplay).toContain('✅ Loaded skill');
+    });
+
+    it('should provide detailed debug info when skill not found', async () => {
+      const mockSkills = [
+        {
+          id: 'marketplace:plugin1:skill1',
+          name: 'skill1',
+          description: 'Skill 1',
+          pluginId: 'marketplace:plugin1',
+          marketplaceId: 'marketplace',
+          path: '/mock/path1',
+          skillFilePath: '/mock/path1/SKILL.md',
+          metadata: { name: 'skill1' },
+          enabled: true,
+          loadLevel: SkillLoadLevel.RESOURCES,
+          scripts: [],
+        },
+        {
+          id: 'marketplace:plugin2:skill2',
+          name: 'skill2',
+          description: 'Skill 2',
+          pluginId: 'marketplace:plugin2',
+          marketplaceId: 'marketplace',
+          path: '/mock/path2',
+          skillFilePath: '/mock/path2/SKILL.md',
+          metadata: { name: 'skill2' },
+          enabled: true,
+          loadLevel: SkillLoadLevel.RESOURCES,
+          scripts: [],
+        },
+      ];
+
+      mockLoaderInstance = {
+        loadEnabledSkills: () => mockSkills,
+      };
+
+      const result = await useSkillTool.execute({ skillName: 'nonexistent' }, mockAbortSignal);
+
+      // Should provide debug information
+      expect(result.llmContent).toContain('❌ Skill "nonexistent" not found');
+      expect(result.llmContent).toContain('📊 Debug Information');
+      expect(result.llmContent).toContain('Total skills loaded: 2');
+      expect(result.llmContent).toContain('Normalized search: "nonexistent"');
+      expect(result.llmContent).toContain('By name:');
+      expect(result.llmContent).toContain('skill1');
+      expect(result.llmContent).toContain('skill2');
+      expect(result.llmContent).toContain('By ID:');
+      expect(result.llmContent).toContain('marketplace:plugin1:skill1');
+      expect(result.llmContent).toContain('marketplace:plugin2:skill2');
+      expect(result.llmContent).toContain('Inconsistency between list and use_skill');
+    });
+  });
 });

packages/core/src/tools/use-skill.ts

@@ -155,6 +155,14 @@ To use skills, please run DeepV Code from the command line.`,
       // Find the skill by name
       const skills = await loader.loadEnabledSkills(SkillLoadLevel.RESOURCES);
 
+      // Debug logging for skill discovery issues
+      if (process.env.DEBUG_SKILLS) {
+        console.log(`[use_skill] Loaded ${skills.length} skills from SkillLoader:`);
+        skills.forEach((s: Skill) => {
+          console.log(`  - ${s.name} (id: ${s.id}, isCustom: ${s.isCustom}, location: ${s.location?.type || 'N/A'})`);
+        });
+      }
+
       // 更健壮的匹配逻辑：支持多种格式
       const normalizedSearchName = params.skillName.toLowerCase().trim();
       const matchingSkills = skills.filter((s: Skill) => {
@@ -178,16 +186,36 @@ To use skills, please run DeepV Code from the command line.`,
 
       if (matchingSkills.length === 0) {
         const availableSkills = skills.map((s: Skill) => `${s.name} (id: ${s.id})`).join(', ');
+        const availableNames = skills.map((s: Skill) => s.name).sort().join(', ');
+        const availableIds = skills.map((s: Skill) => s.id).sort().join(', ');
+
         return {
           llmContent: `❌ Skill "${params.skillName}" not found.
 
-Available skills (${skills.length} total): ${availableSkills || 'none'}
-
-Possible issues:
-- Skill name is incorrect (check spelling and case)
-- Skill is not installed (use /skill list to see all skills)
-- Plugin is disabled
-- Skill is in a different location (user-global vs project-level)
+📊 Debug Information:
+  - Your search: "${params.skillName}"
+  - Normalized search: "${normalizedSearchName}"
+  - Total skills loaded: ${skills.length}
+  - Loader source: SkillLoader.loadEnabledSkills()
+
+📋 Available skills (${skills.length} total):
+  By name: ${availableNames || 'none'}
+
+  By ID: ${availableIds || 'none'}
+
+🔍 Possible issues:
+  - Skill name is incorrect (check spelling and case-sensitivity)
+  - Skill is not installed (use /skill list to see all skills)
+  - Plugin is disabled (use /skill plugin list to check status)
+  - Skill is in a different location (user-global vs project-level)
+  - ⚠️ Inconsistency between list and use_skill (this may be a bug)
+
+💡 Troubleshooting steps:
+  1. Run: /skill list (to see all discoverable skills)
+  2. If you can see the skill with /skill list but not here, this indicates a
+     skill discovery inconsistency - please report this as a bug
+  3. Check plugin status: /skill plugin list
+  4. Try using the full skill ID instead of just the name
 
 To see detailed skill information, check the "Available Skills" section in the system context.`,
           returnDisplay: `Skill "${params.skillName}" not found`,

packages/vscode-ui-plugin/src/extension.ts

@@ -2679,6 +2679,25 @@ function setupMultiSessionHandlers() {
     }
   });
 
+  // 🎯 处理Session拖拽排序请求
+  communicationService.addMessageHandler('session_reorder', async (payload: { sessionIds: string[] }) => {
+    try {
+      logger.info('Received session_reorder request', { sessionIds: payload.sessionIds.map(id => id.substring(0, 8)) });
+
+      // 调用持久化服务保存新顺序
+      await sessionManager.saveSessionsOrder(payload.sessionIds);
+
+      logger.info('✅ Session order saved successfully');
+
+      // 🎯 注意：不发送 session_list_update！
+      // 前端已经通过 reorderSessions 更新了 UI，
+      // 如果发送 session_list_update，会覆盖前端的拖拽顺序
+      // （因为 getAllSessionsInfo() 按 lastActivity 排序，不是用户自定义顺序）
+    } catch (error) {
+      logger.error('Failed to reorder sessions', error instanceof Error ? error : undefined);
+    }
+  });
+
   // 处理Session更新请求
   communicationService.onSessionUpdate(async (payload) => {
     try {

packages/vscode-ui-plugin/src/services/sessionManager.ts

@@ -55,6 +55,9 @@ export class SessionManager extends EventEmitter {
   private currentSessionId: string | null = null;
   private isInitialized = false;
 
+  // 🎯 Session 顺序管理（用于拖拽排序）
+  private sessionsOrder: string[] = [];
+
   // 🎯 用户内存/上下文内容缓存（全局共享）
   private userMemoryContent: string = '';
   private userMemoryFileCount: number = 0;
@@ -140,6 +143,8 @@ export class SessionManager extends EventEmitter {
         const persistedSessions = await this.persistenceService.loadSessions();
         if (persistedSessions.length > 0) {
           await this.restoreSessions(persistedSessions);
+          // 🎯 初始化 sessionsOrder（按持久化层的顺序，支持拖拽排序）
+          this.sessionsOrder = persistedSessions.map(s => s.info.id);
           this.logger.info(`📦 Restored ${persistedSessions.length} persisted sessions`);
         } else {
           // 没有持久化会话，创建默认会话
@@ -460,6 +465,9 @@ export class SessionManager extends EventEmitter {
       this.sessions.set(sessionState.info.id, sessionState);
       this.aiServices.set(sessionState.info.id, aiService);
 
+      // 🎯 将新 session 添加到顺序列表开头（最新创建的在前）
+      this.sessionsOrder = [sessionId, ...this.sessionsOrder];
+
       // 🎯 如果需要激活，设置为当前session并将之前的session设为IDLE
       if (shouldActivate) {
         // 将之前的current session设为IDLE
@@ -532,6 +540,9 @@ export class SessionManager extends EventEmitter {
         this.logger.info(`🗑️ Session ${sessionId} not in memory, deleting directly from disk...`);
       }
 
+      // 🎯 从顺序列表中移除
+      this.sessionsOrder = this.sessionsOrder.filter(id => id !== sessionId);
+
       // 🎯 无论是否在内存中，都从持久化存储中删除
       await this.persistenceService.deleteSession(sessionId);
       this.logger.info(`✅ Deleted session from disk: ${sessionId}`);
@@ -738,11 +749,46 @@ export class SessionManager extends EventEmitter {
 
   /**
    * 获取所有会话信息列表
+   * 🎯 按用户自定义的拖拽顺序返回（如果有），否则按 lastActivity 排序
    */
   getAllSessionsInfo(): SessionInfo[] {
-    return Array.from(this.sessions.values())
-      .map(session => session.info)
-      .sort((a, b) => b.lastActivity - a.lastActivity);
+    const allSessions = Array.from(this.sessions.values()).map(session => session.info);
+
+    // 🎯 如果有自定义顺序，按顺序返回
+    if (this.sessionsOrder.length > 0) {
+      const orderedSessions: SessionInfo[] = [];
+      const sessionMap = new Map(allSessions.map(s => [s.id, s]));
+
+      // 按 sessionsOrder 顺序添加
+      for (const id of this.sessionsOrder) {
+        const session = sessionMap.get(id);
+        if (session) {
+          orderedSessions.push(session);
+          sessionMap.delete(id);
+        }
+      }
+
+      // 添加不在 sessionsOrder 中的新 session（按 lastActivity 排序）
+      const remainingSessions = Array.from(sessionMap.values())
+        .sort((a, b) => b.lastActivity - a.lastActivity);
+      orderedSessions.push(...remainingSessions);
+
+      return orderedSessions;
+    }
+
+    // 没有自定义顺序时，按 lastActivity 排序
+    return allSessions.sort((a, b) => b.lastActivity - a.lastActivity);
+  }
+
+  /**
+   * 🎯 保存Session顺序（用于拖拽排序）
+   * @param sessionIds 按用户拖拽后的新顺序排列的sessionId数组
+   */
+  async saveSessionsOrder(sessionIds: string[]): Promise<void> {
+    // 🎯 同时更新内存中的顺序
+    this.sessionsOrder = [...sessionIds];
+    await this.persistenceService.saveSessionsOrder(sessionIds);
+    this.logger.info(`✅ Session order saved: ${sessionIds.length} sessions`);
   }
 
   /**