autosnippet 3.0.0 → 3.0.2

package/lib/core/discovery/DiscovererRegistry.js

@@ -0,0 +1,83 @@
+/**
+ * @module DiscovererRegistry
+ * @description 注册所有 Discoverer 实现，按项目根目录自动选择最佳匹配。
+ *
+ * 检测顺序：按 confidence 降序。多个匹配时取最高 confidence。
+ * 若全部未命中，回退到 GenericDiscoverer（目录扫描兜底）。
+ */
+
+export class DiscovererRegistry {
+  /** @type {import('./ProjectDiscoverer.js').ProjectDiscoverer[]} */
+  #discoverers = [];
+
+  /**
+   * 注册一个 Discoverer 实现
+   * @param {import('./ProjectDiscoverer.js').ProjectDiscoverer} discoverer
+   * @returns {DiscovererRegistry} this — 支持链式调用
+   */
+  register(discoverer) {
+    this.#discoverers.push(discoverer);
+    return this;
+  }
+
+  /**
+   * 自动检测项目类型，返回最佳 Discoverer
+   * @param {string} projectRoot
+   * @returns {Promise<import('./ProjectDiscoverer.js').ProjectDiscoverer>}
+   */
+  async detect(projectRoot) {
+    const results = await Promise.all(
+      this.#discoverers.map(async (d) => ({
+        discoverer: d,
+        result: await d
+          .detect(projectRoot)
+          .catch(() => ({ match: false, confidence: 0, reason: 'detect error' })),
+      }))
+    );
+
+    const matched = results
+      .filter((r) => r.result.match)
+      .sort((a, b) => b.result.confidence - a.result.confidence);
+
+    if (matched.length > 0) {
+      return matched[0].discoverer;
+    }
+
+    // 回退到 GenericDiscoverer
+    const generic = this.#discoverers.find((d) => d.id === 'generic');
+    if (generic) {
+      return generic;
+    }
+
+    throw new Error('No Discoverer matched and no GenericDiscoverer registered');
+  }
+
+  /**
+   * 检测所有匹配的 Discoverer（用于混合项目）
+   * @param {string} projectRoot
+   * @returns {Promise<Array<{ discoverer: import('./ProjectDiscoverer.js').ProjectDiscoverer, confidence: number }>>}
+   */
+  async detectAll(projectRoot) {
+    const results = await Promise.all(
+      this.#discoverers.map(async (d) => ({
+        discoverer: d,
+        result: await d
+          .detect(projectRoot)
+          .catch(() => ({ match: false, confidence: 0, reason: 'detect error' })),
+      }))
+    );
+
+    return results
+      .filter((r) => r.result.match)
+      .sort((a, b) => b.result.confidence - a.result.confidence)
+      .map((r) => ({ discoverer: r.discoverer, confidence: r.result.confidence }));
+  }
+
+  /**
+   * 获取所有已注册的 Discoverer
+   * @returns {import('./ProjectDiscoverer.js').ProjectDiscoverer[]}
+   */
+  getAll() {
+    return [...this.#discoverers];
+  }
+}

package/lib/core/discovery/GenericDiscoverer.js

@@ -0,0 +1,225 @@
+/**
+ * @module GenericDiscoverer
+ * @description 通用兜底项目结构发现器
+ *
+ * 始终匹配，confidence 0.1。
+ * 按语言统计最多的扩展名确定主语言。
+ * 按顶层目录分 Target。
+ */
+
+import { existsSync, readdirSync } from 'node:fs';
+import { basename, extname, join, relative } from 'node:path';
+import { inferLang } from '../../external/mcp/handlers/LanguageExtensions.js';
+import { ProjectDiscoverer } from './ProjectDiscoverer.js';
+
+const EXCLUDE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'out',
+  '.build',
+  'target',
+  'Pods',
+  'Carthage',
+  'DerivedData',
+  '__pycache__',
+  '.venv',
+  'venv',
+  '.gradle',
+  '.idea',
+  'vendor',
+  'coverage',
+  '.cache',
+]);
+
+const SOURCE_EXTENSIONS = new Set([
+  '.ts',
+  '.tsx',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.py',
+  '.java',
+  '.kt',
+  '.kts',
+  '.swift',
+  '.m',
+  '.h',
+  '.mm',
+  '.go',
+  '.dart',
+  '.rs',
+  '.rb',
+  '.c',
+  '.cpp',
+  '.cs',
+  '.vue',
+  '.svelte',
+]);
+
+export class GenericDiscoverer extends ProjectDiscoverer {
+  #projectRoot = null;
+  #targets = [];
+  #primaryLang = 'unknown';
+
+  get id() {
+    return 'generic';
+  }
+  get displayName() {
+    return 'Generic (directory scan)';
+  }
+
+  async detect(projectRoot) {
+    // 始终匹配
+    return { match: true, confidence: 0.1, reason: 'Generic fallback discoverer' };
+  }
+
+  async load(projectRoot) {
+    this.#projectRoot = projectRoot;
+    this.#targets = [];
+
+    // 统计语言分布
+    const langStats = {};
+    this.#scanLangStats(projectRoot, langStats, 0);
+
+    // 找到主语言
+    let maxCount = 0;
+    for (const [lang, count] of Object.entries(langStats)) {
+      if (count > maxCount) {
+        maxCount = count;
+        this.#primaryLang = lang;
+      }
+    }
+
+    // 按顶层约定目录分 Target
+    const targetDirs = ['src', 'lib', 'app', 'pkg', 'cmd', 'internal', 'test', 'tests'];
+    let foundTargets = false;
+
+    try {
+      const entries = readdirSync(projectRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        if (entry.name.startsWith('.') || EXCLUDE_DIRS.has(entry.name)) {
+          continue;
+        }
+
+        if (targetDirs.includes(entry.name.toLowerCase())) {
+          const isTest = /^tests?$/.test(entry.name);
+          this.#targets.push({
+            name: entry.name,
+            path: join(projectRoot, entry.name),
+            type: isTest ? 'test' : 'library',
+            language: this.#primaryLang,
+          });
+          foundTargets = true;
+        }
+      }
+    } catch {
+      /* skip */
+    }
+
+    // 没有约定目录则整个项目为一个 Target
+    if (!foundTargets) {
+      this.#targets.push({
+        name: basename(projectRoot),
+        path: projectRoot,
+        type: 'library',
+        language: this.#primaryLang,
+      });
+    }
+  }
+
+  async listTargets() {
+    return this.#targets;
+  }
+
+  async getTargetFiles(target) {
+    const targetPath =
+      typeof target === 'string'
+        ? this.#targets.find((t) => t.name === target)?.path || this.#projectRoot
+        : target.path;
+
+    if (!targetPath || !existsSync(targetPath)) {
+      return [];
+    }
+
+    const files = [];
+    this.#collectFiles(targetPath, targetPath, files);
+    return files;
+  }
+
+  async getDependencyGraph() {
+    // GenericDiscoverer 无法推断依赖图
+    return { nodes: this.#targets.map((t) => t.name), edges: [] };
+  }
+
+  // ── 内部实现 ──
+
+  #scanLangStats(dir, stats, depth) {
+    if (depth > 5) {
+      return; // 限制深度, 只采样
+    }
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+          continue;
+        }
+        if (EXCLUDE_DIRS.has(entry.name)) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          this.#scanLangStats(join(dir, entry.name), stats, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name);
+          if (SOURCE_EXTENSIONS.has(ext)) {
+            const lang = inferLang(entry.name) || 'unknown';
+            stats[lang] = (stats[lang] || 0) + 1;
+          }
+        }
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  #collectFiles(dir, rootDir, files, depth = 0) {
+    if (depth > 15) {
+      return;
+    }
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+          continue;
+        }
+        if (EXCLUDE_DIRS.has(entry.name)) {
+          continue;
+        }
+
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          this.#collectFiles(fullPath, rootDir, files, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name);
+          if (SOURCE_EXTENSIONS.has(ext)) {
+            const lang = inferLang(entry.name) || 'unknown';
+            files.push({
+              name: entry.name,
+              path: fullPath,
+              relativePath: relative(rootDir, fullPath),
+              language: lang,
+            });
+          }
+        }
+      }
+    } catch {
+      /* skip */
+    }
+  }
+}