autosnippet 3.0.0 → 3.0.2

package/lib/external/mcp/handlers/bootstrap/pipeline/tier-scheduler.js

@@ -2,11 +2,12 @@
  * TierScheduler.js — 维度分层并行调度器
  *
  * 按维度间信息依赖关系分 3 层执行:
- * - Tier 1: 基础数据层 (project-profile, objc-deep-scan, category-scan) — 可并行
+ * - Tier 1: 基础数据层 (project-profile, 语言条件扫描) — 可并行
  * - Tier 2: 规范+架构+模式 (code-standard, architecture, code-pattern) — 依赖 Tier 1
  * - Tier 3: 流转+实践+总结 (event-and-data-flow, best-practice, agent-guidelines) — 依赖 Tier 2
  *
  * 每层内部可并行 (受 concurrency 限制)，层间串行。
+ * 未在任何 Tier 中定义的维度会自动归入 Tier 1（并行执行）。
  *
  * @module TierScheduler
  */
@@ -20,9 +21,20 @@ const logger = Logger.getInstance();
 // ──────────────────────────────────────────────────────────────────
 
 const DEFAULT_TIERS = [
-  ['project-profile', 'objc-deep-scan', 'category-scan'],                   // Tier 1: 基础数据
-  ['code-standard', 'architecture', 'code-pattern'],                        // Tier 2: 规范+架构+模式
-  ['event-and-data-flow', 'best-practice', 'agent-guidelines'],             // Tier 3: 流转+实践+总结
+  // Tier 1: 基础数据（通用 + 语言条件维度并行执行）
+  [
+    'project-profile',
+    'objc-deep-scan',
+    'category-scan',
+    'module-export-scan',
+    'framework-convention-scan',
+    'python-package-scan',
+    'jvm-annotation-scan',
+  ],
+  // Tier 2: 规范+架构+模式
+  ['code-standard', 'architecture', 'code-pattern'],
+  // Tier 3: 流转+实践+总结
+  ['event-and-data-flow', 'best-practice', 'agent-guidelines'],
 ];
 
 // ──────────────────────────────────────────────────────────────────
@@ -42,7 +54,7 @@ class Semaphore {
       this.#permits--;
       return;
     }
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
       this.#queue.push(resolve);
     });
   }
@@ -80,21 +92,43 @@ export class TierScheduler {
    * @param {number} [options.concurrency=3] — Tier 内最大并行数
    * @param {Function} [options.onTierComplete] — (tierIndex, tierResults) => void
    * @param {Function} [options.shouldAbort] — () => boolean — 外部中止信号
+   * @param {string[]} [options.activeDimIds] — 实际要执行的维度 ID 列表（过滤不在列表中的维度）
    * @returns {Promise<Map<string, any>>} — dimId → result
    */
   async execute(executeDimension, options = {}) {
-    const { concurrency = 3, onTierComplete, shouldAbort } = options;
+    const { concurrency = 3, onTierComplete, shouldAbort, activeDimIds } = options;
     const results = new Map();
 
-    for (let tierIndex = 0; tierIndex < this.#tiers.length; tierIndex++) {
-      const tier = this.#tiers[tierIndex];
+    // 如果提供了 activeDimIds，根据它构建实际要执行的 tiers
+    // 未在任何 tier 中定义的维度追加到 Tier 1
+    let effectiveTiers = this.#tiers;
+    if (activeDimIds) {
+      const activeSet = new Set(activeDimIds);
+      const scheduled = new Set(this.#tiers.flat());
+      const unscheduled = activeDimIds.filter((id) => !scheduled.has(id));
+      effectiveTiers = this.#tiers.map((tier) => tier.filter((id) => activeSet.has(id)));
+      if (unscheduled.length > 0) {
+        // 动态维度（Enhancement Pack 追加的）归入 Tier 1
+        effectiveTiers[0] = [...effectiveTiers[0], ...unscheduled];
+        logger.info(
+          `[TierScheduler] Unscheduled dims added to Tier 1: [${unscheduled.join(', ')}]`
+        );
+      }
+      // 移除空 tier
+      effectiveTiers = effectiveTiers.filter((t) => t.length > 0);
+    }
+
+    for (let tierIndex = 0; tierIndex < effectiveTiers.length; tierIndex++) {
+      const tier = effectiveTiers[tierIndex];
 
       if (shouldAbort?.()) {
         logger.warn(`[TierScheduler] Aborted before Tier ${tierIndex + 1}`);
         break;
       }
 
-      logger.info(`[TierScheduler] ── Tier ${tierIndex + 1}/${this.#tiers.length}: [${tier.join(', ')}] (concurrency=${concurrency})`);
+      logger.info(
+        `[TierScheduler] ── Tier ${tierIndex + 1}/${this.#tiers.length}: [${tier.join(', ')}] (concurrency=${concurrency})`
+      );
 
       const tierResults = await this.#executeTier(tier, executeDimension, concurrency, shouldAbort);
 
@@ -117,11 +151,15 @@ export class TierScheduler {
 
     await Promise.all(
       dimensionIds.map(async (dimId) => {
-        if (shouldAbort?.()) return;
+        if (shouldAbort?.()) {
+          return;
+        }
 
         await semaphore.acquire();
         try {
-          if (shouldAbort?.()) return;
+          if (shouldAbort?.()) {
+            return;
+          }
           const result = await executeDimension(dimId);
           results.set(dimId, result);
         } catch (err) {
@@ -143,7 +181,9 @@ export class TierScheduler {
    */
   getTierIndex(dimId) {
     for (let i = 0; i < this.#tiers.length; i++) {
-      if (this.#tiers[i].includes(dimId)) return i;
+      if (this.#tiers[i].includes(dimId)) {
+        return i;
+      }
     }
     return -1;
   }

package/lib/external/mcp/handlers/bootstrap/skills.js

@@ -18,9 +18,14 @@ const SKILLS_DIR = path.resolve(__dirname, '../../../../../skills');
  * 语言 → Skills 映射（Skills 必须位于内置 skills/ 目录）
  */
 const LANG_SKILL_MAP = {
-  objectivec: ['autosnippet-coldstart', 'reference-objc'],
-  swift: ['autosnippet-coldstart', 'reference-swift'],
-  // 未来扩展: kotlin, java, python, typescript ...
+  objectivec: ['autosnippet-coldstart', 'autosnippet-reference-objc'],
+  swift: ['autosnippet-coldstart', 'autosnippet-reference-swift'],
+  typescript: ['autosnippet-coldstart', 'autosnippet-reference-jsts'],
+  javascript: ['autosnippet-coldstart', 'autosnippet-reference-jsts'],
+  python: ['autosnippet-coldstart', 'autosnippet-reference-python'],
+  java: ['autosnippet-coldstart', 'autosnippet-reference-java'],
+  kotlin: ['autosnippet-coldstart', 'autosnippet-reference-kotlin'],
+  go: ['autosnippet-coldstart', 'autosnippet-reference-go'],
 };
 
 /**
@@ -32,7 +37,8 @@ const LANG_SKILL_MAP = {
  */
 export function loadBootstrapSkills(primaryLanguage, logger) {
   const result = { coldstartSkill: null, languageSkill: null, loaded: [] };
-  const skillNames = LANG_SKILL_MAP[primaryLanguage] || LANG_SKILL_MAP.swift;
+  const skillNames = LANG_SKILL_MAP[primaryLanguage] ||
+    LANG_SKILL_MAP.typescript || ['autosnippet-coldstart'];
 
   for (const skillName of skillNames) {
     const skillPath = path.join(SKILLS_DIR, skillName, 'SKILL.md');
@@ -41,7 +47,7 @@ export function loadBootstrapSkills(primaryLanguage, logger) {
         const content = fs.readFileSync(skillPath, 'utf8');
         if (skillName.startsWith('autosnippet-coldstart')) {
           result.coldstartSkill = content;
-        } else if (skillName.startsWith('reference-')) {
+        } else if (skillName.includes('reference-')) {
           result.languageSkill = content;
         }
         result.loaded.push(skillName);
@@ -69,18 +75,22 @@ export function loadBootstrapSkills(primaryLanguage, logger) {
  * @returns {{ guides: Record<string, string>, sectionMap: Record<string, Array<{title: string, content: string, keywords: string[]}>> }}
  */
 export function extractSkillDimensionGuides(skillContext) {
-  const guides = {};      // dimId → summary guide text
-  const sectionMap = {};   // dimId → [{title, content, keywords}]
+  const guides = {}; // dimId → summary guide text
+  const sectionMap = {}; // dimId → [{title, content, keywords}]
   const hasLanguageSkill = !!skillContext.languageSkill;
 
   // ── coldstart 模板: 仅在无语言 Skill 时用作 fallback ──
   // coldstart 中的 rationale/whyStandard 是 Swift 示例，不适合直接注入其它语言项目
   if (skillContext.coldstartSkill && !hasLanguageSkill) {
     const content = skillContext.coldstartSkill;
-    const dimBlocks = content.matchAll(/###\s+维度\s*\d+\s*[:：]\s*(.+?)\s*\(([^)]+)\)\s*[—–-]\s*参考模板\s*\n([\s\S]*?)(?=\n###\s|\n##\s)/g);
+    const dimBlocks = content.matchAll(
+      /###\s+维度\s*\d+\s*[:：]\s*(.+?)\s*\(([^)]+)\)\s*[—–-]\s*参考模板\s*\n([\s\S]*?)(?=\n###\s|\n##\s)/g
+    );
     for (const match of dimBlocks) {
       let dimId = match[2].trim();
-      if (/solution|antiPattern|bug/i.test(dimId)) dimId = 'anti-pattern';
+      if (/solution|antiPattern|bug/i.test(dimId)) {
+        dimId = 'anti-pattern';
+      }
       dimId = dimId.replace(/\s+/g, '-');
       const block = match[3];
       const rationaleMatch = block.match(/"rationale"\s*:\s*"([^"]{20,300})"/);
@@ -98,26 +108,86 @@ export function extractSkillDimensionGuides(skillContext) {
 
     // heading → dimension(s) + 子主题匹配关键词
     const HEADING_DIM_MAP = [
-      { pattern: /命名|naming|前缀|prefix/i,            dims: ['code-standard', 'code-pattern'], keywords: ['naming', 'prefix', '命名', '前缀', 'category'] },
-      { pattern: /属性|propert/i,                        dims: ['code-standard', 'best-practice', 'anti-pattern'], keywords: ['property', '属性', 'copy', 'weak', 'strong', 'memory', 'retain', 'cycle', 'leak'] },
-      { pattern: /delegate|委托/i,                       dims: ['event-and-data-flow', 'code-pattern'],  keywords: ['delegate', 'protocol', '委托', '协议'] },
-      { pattern: /初始化|initializ/i,                    dims: ['code-pattern'],                keywords: ['init', 'initializer', '初始化', 'factory'] },
-      { pattern: /null|可选/i,                           dims: ['code-standard'],               keywords: ['nullable', 'nonnull', 'nullability'] },
-      { pattern: /错误处理|error/i,                      dims: ['best-practice'],               keywords: ['error', 'NSError', '错误', 'error-handling'] },
-      { pattern: /bool|陷阱/i,                           dims: ['anti-pattern'],                keywords: ['BOOL', 'bool', '陷阱', 'trap'] },
-      { pattern: /gcd|线程|thread|并发|concurrent/i,     dims: ['best-practice', 'anti-pattern'], keywords: ['GCD', 'dispatch', 'thread', '线程', 'main', 'concurrency', 'main-thread'] },
-      { pattern: /泛型|generic/i,                        dims: ['code-standard'],               keywords: ['generics', '泛型', 'generic'] },
-      { pattern: /import|导入/i,                         dims: ['code-standard'],               keywords: ['import', '#import', '导入', 'file-organization'] },
-      { pattern: /特有维度|extra.?dim/i,                 dims: ['agent-guidelines'],            keywords: ['agent', '注意', '维度', 'extra'] },
-      { pattern: /category|扩展(?!.*特有)/i,             dims: ['code-pattern'],                keywords: ['category', 'extension', '扩展'] },
-      { pattern: /singleton|单例/i,                      dims: ['code-pattern'],                keywords: ['singleton', '单例', 'dispatch_once'] },
+      {
+        pattern: /命名|naming|前缀|prefix/i,
+        dims: ['code-standard', 'code-pattern'],
+        keywords: ['naming', 'prefix', '命名', '前缀', 'category'],
+      },
+      {
+        pattern: /属性|propert/i,
+        dims: ['code-standard', 'best-practice', 'anti-pattern'],
+        keywords: [
+          'property',
+          '属性',
+          'copy',
+          'weak',
+          'strong',
+          'memory',
+          'retain',
+          'cycle',
+          'leak',
+        ],
+      },
+      {
+        pattern: /delegate|委托/i,
+        dims: ['event-and-data-flow', 'code-pattern'],
+        keywords: ['delegate', 'protocol', '委托', '协议'],
+      },
+      {
+        pattern: /初始化|initializ/i,
+        dims: ['code-pattern'],
+        keywords: ['init', 'initializer', '初始化', 'factory'],
+      },
+      {
+        pattern: /null|可选/i,
+        dims: ['code-standard'],
+        keywords: ['nullable', 'nonnull', 'nullability'],
+      },
+      {
+        pattern: /错误处理|error/i,
+        dims: ['best-practice'],
+        keywords: ['error', 'NSError', '错误', 'error-handling'],
+      },
+      { pattern: /bool|陷阱/i, dims: ['anti-pattern'], keywords: ['BOOL', 'bool', '陷阱', 'trap'] },
+      {
+        pattern: /gcd|线程|thread|并发|concurrent/i,
+        dims: ['best-practice', 'anti-pattern'],
+        keywords: ['GCD', 'dispatch', 'thread', '线程', 'main', 'concurrency', 'main-thread'],
+      },
+      {
+        pattern: /泛型|generic/i,
+        dims: ['code-standard'],
+        keywords: ['generics', '泛型', 'generic'],
+      },
+      {
+        pattern: /import|导入/i,
+        dims: ['code-standard'],
+        keywords: ['import', '#import', '导入', 'file-organization'],
+      },
+      {
+        pattern: /特有维度|extra.?dim/i,
+        dims: ['agent-guidelines'],
+        keywords: ['agent', '注意', '维度', 'extra'],
+      },
+      {
+        pattern: /category|扩展(?!.*特有)/i,
+        dims: ['code-pattern'],
+        keywords: ['category', 'extension', '扩展'],
+      },
+      {
+        pattern: /singleton|单例/i,
+        dims: ['code-pattern'],
+        keywords: ['singleton', '单例', 'dispatch_once'],
+      },
     ];
 
     // 用 --- 分割section，更可靠地提取完整 section body
     const sectionParts = content.split(/\n---\n/);
     for (const part of sectionParts) {
       const headingMatch = part.match(/^##\s+\d+\.\s+(.+?)(?:\s*\(.+\))?\s*$/m);
-      if (!headingMatch) continue;
+      if (!headingMatch) {
+        continue;
+      }
 
       const heading = headingMatch[1].trim();
       const bodyStart = part.indexOf(headingMatch[0]) + headingMatch[0].length;
@@ -125,7 +195,7 @@ export function extractSkillDimensionGuides(skillContext) {
 
       // 查找匹配的 dimension(s)
       let matchedDims = [];
-      let matchedKeywords = [];
+      const matchedKeywords = [];
       for (const mapping of HEADING_DIM_MAP) {
         if (mapping.pattern.test(heading)) {
           matchedDims.push(...mapping.dims);
@@ -133,7 +203,9 @@ export function extractSkillDimensionGuides(skillContext) {
         }
       }
       matchedDims = [...new Set(matchedDims)];
-      if (matchedDims.length === 0) continue;
+      if (matchedDims.length === 0) {
+        continue;
+      }
 
       // 提取有意义的摘要内容
       let summary = extractSectionSummary(body);
@@ -141,7 +213,9 @@ export function extractSkillDimensionGuides(skillContext) {
       if (summary.length < 20) {
         summary = `${heading}：${summary}`;
       }
-      if (summary.length < 10) continue;
+      if (summary.length < 10) {
+        continue;
+      }
 
       const sectionData = {
         title: heading,
@@ -150,7 +224,9 @@ export function extractSkillDimensionGuides(skillContext) {
       };
 
       for (const dimId of matchedDims) {
-        if (!sectionMap[dimId]) sectionMap[dimId] = [];
+        if (!sectionMap[dimId]) {
+          sectionMap[dimId] = [];
+        }
         sectionMap[dimId].push(sectionData);
 
         const shortContent = summary.substring(0, 120);
@@ -180,25 +256,49 @@ export function extractSectionSummary(body) {
     const trimmed = line.trim();
 
     // 跳过 JSON 模板块（候选格式示例）
-    if (trimmed.startsWith('```json')) { inJsonBlock = true; continue; }
-    if (inJsonBlock) { if (trimmed === '```') inJsonBlock = false; continue; }
+    if (trimmed.startsWith('```json')) {
+      inJsonBlock = true;
+      continue;
+    }
+    if (inJsonBlock) {
+      if (trimmed === '```') {
+        inJsonBlock = false;
+      }
+      continue;
+    }
 
     // 追踪代码块 — 保留 ✅/❌ 关键注释
-    if (trimmed.startsWith('```')) { inCodeBlock = !inCodeBlock; continue; }
+    if (trimmed.startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
     if (inCodeBlock) {
-      if (/[✅❌]/.test(trimmed) && parts.length < 12) parts.push(trimmed);
+      if (/[✅❌]/.test(trimmed) && parts.length < 12) {
+        parts.push(trimmed);
+      }
       continue;
     }
 
-    if (!trimmed) continue;
-    if (trimmed.startsWith('###') || trimmed.startsWith('####')) continue;
-    if (/^\|[-\s|:]+\|$/.test(trimmed)) continue; // 表格分隔线
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed.startsWith('###') || trimmed.startsWith('####')) {
+      continue;
+    }
+    if (/^\|[-\s|:]+\|$/.test(trimmed)) {
+      continue; // 表格分隔线
+    }
 
     parts.push(trimmed);
-    if (parts.length >= 10) break;
+    if (parts.length >= 10) {
+      break;
+    }
   }
 
-  return parts.join('; ').replace(/\s{2,}/g, ' ').trim();
+  return parts
+    .join('; ')
+    .replace(/\s{2,}/g, ' ')
+    .trim();
 }
 
 /**
@@ -210,11 +310,15 @@ export function extractSectionSummary(body) {
  * @returns {Array} 增强后的维度数组（原数组不变，返回新数组）
  */
 export function enhanceDimensions(dimensions, skillGuides, skillSections) {
-  if (!skillGuides || Object.keys(skillGuides).length === 0) return dimensions;
+  if (!skillGuides || Object.keys(skillGuides).length === 0) {
+    return dimensions;
+  }
 
-  return dimensions.map(dim => {
+  return dimensions.map((dim) => {
     const extra = skillGuides[dim.id];
-    if (!extra) return dim;
+    if (!extra) {
+      return dim;
+    }
     return {
       ...dim,
       guide: `${dim.guide}。[Skill 参考] ${extra}`,