autosnippet 3.0.0 → 3.0.2

package/lib/core/discovery/NodeDiscoverer.js

@@ -0,0 +1,466 @@
+/**
+ * @module NodeDiscoverer
+ * @description TypeScript / JavaScript 项目结构发现器
+ *
+ * 检测信号: package.json, tsconfig.json, node_modules/
+ * 支持: 单包、Monorepo (npm/pnpm/yarn workspaces, lerna)
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, extname, join, relative, resolve } from 'node:path';
+import { inferLang } from '../../external/mcp/handlers/LanguageExtensions.js';
+import { ProjectDiscoverer } from './ProjectDiscoverer.js';
+
+const SOURCE_EXTENSIONS = new Set([
+  '.ts',
+  '.tsx',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.vue',
+  '.svelte',
+]);
+const EXCLUDE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'out',
+  '.next',
+  '.nuxt',
+  'coverage',
+  '.turbo',
+  '.cache',
+]);
+
+export class NodeDiscoverer extends ProjectDiscoverer {
+  #projectRoot = null;
+  #packageJson = null;
+  #targets = [];
+  #depGraph = { nodes: [], edges: [] };
+
+  get id() {
+    return 'node';
+  }
+  get displayName() {
+    return 'Node.js (npm/pnpm/yarn)';
+  }
+
+  async detect(projectRoot) {
+    let confidence = 0;
+    const reasons = [];
+
+    if (existsSync(join(projectRoot, 'package.json'))) {
+      confidence = 0.9;
+      reasons.push('package.json exists');
+    }
+    if (existsSync(join(projectRoot, 'tsconfig.json'))) {
+      confidence = Math.max(confidence, 0.9);
+      confidence += 0.05;
+      reasons.push('tsconfig.json exists');
+    }
+    if (existsSync(join(projectRoot, 'node_modules'))) {
+      confidence += 0.05;
+      reasons.push('node_modules/ exists');
+    }
+
+    // ── 降低 confidence：当检测到其他生态的强标记时 ──────────
+    // 这些项目使用 package.json 仅作为前端/工具链辅助，主语言在别的生态
+    if (confidence > 0) {
+      // Ruby 生态：Gemfile/Rakefile 的存在几乎确定是 Rails/Sinatra 项目
+      // 即使有 tsconfig.json 也只是说明前端构建链使用 TS（Ember/React），
+      // 主语言仍然是 Ruby，因此始终重度降级
+      const rubyMarkers = ['Gemfile', 'Rakefile'];
+      const hasRubyMarker = rubyMarkers.some((f) => existsSync(join(projectRoot, f)));
+      if (hasRubyMarker) {
+        confidence *= 0.05;
+        reasons.push('Ruby marker found (Gemfile/Rakefile) — confidence heavily reduced');
+      } else {
+        // 其他生态标记：tsconfig 存在则可能是全栈项目，保留较高 confidence
+        const otherMarkers = [
+          { files: ['Cargo.toml'], lang: 'Rust' },
+          { files: ['go.mod'], lang: 'Go' },
+        ];
+        for (const marker of otherMarkers) {
+          if (marker.files.some((f) => existsSync(join(projectRoot, f)))) {
+            const hasTsConfig = existsSync(join(projectRoot, 'tsconfig.json'));
+            if (hasTsConfig) {
+              confidence *= 0.5;
+              reasons.push(
+                `${marker.lang} marker found (but tsconfig present) — confidence moderately reduced`
+              );
+            } else {
+              confidence *= 0.05;
+              reasons.push(
+                `${marker.lang} marker found — confidence heavily reduced`
+              );
+            }
+            break;
+          }
+        }
+      }
+    }
+
+    return {
+      match: confidence > 0,
+      confidence: Math.min(confidence, 1.0),
+      reason: reasons.join(', ') || 'No Node.js markers found',
+    };
+  }
+
+  async load(projectRoot) {
+    this.#projectRoot = projectRoot;
+    this.#targets = [];
+    this.#depGraph = { nodes: [], edges: [] };
+
+    // 读取 package.json
+    const pkgPath = join(projectRoot, 'package.json');
+    if (existsSync(pkgPath)) {
+      try {
+        this.#packageJson = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      } catch {
+        this.#packageJson = {};
+      }
+    } else {
+      this.#packageJson = {};
+    }
+
+    // 检测 monorepo workspaces
+    const workspacePaths = this.#resolveWorkspaces(projectRoot);
+
+    if (workspacePaths.length > 0) {
+      // Monorepo 模式: 每个 workspace 是一个 Target
+      for (const wsPath of workspacePaths) {
+        const wsAbsPath = resolve(projectRoot, wsPath);
+        if (!existsSync(wsAbsPath)) {
+          continue;
+        }
+        const wsPkgPath = join(wsAbsPath, 'package.json');
+        let wsPkg = {};
+        if (existsSync(wsPkgPath)) {
+          try {
+            wsPkg = JSON.parse(readFileSync(wsPkgPath, 'utf8'));
+          } catch {
+            /* skip */
+          }
+        }
+
+        const framework = this.#detectFramework(wsPkg);
+        const name = wsPkg.name || basename(wsPath);
+        const type = this.#inferTargetType(wsPkg);
+
+        this.#targets.push({
+          name,
+          path: wsAbsPath,
+          type,
+          language: 'typescript',
+          framework,
+          metadata: { packageJson: wsPkg },
+        });
+        this.#depGraph.nodes.push(name);
+      }
+
+      // 构建 workspace 间依赖
+      this.#buildWorkspaceDeps(workspacePaths);
+    } else {
+      // 单包模式
+      const framework = this.#detectFramework(this.#packageJson);
+      const name = this.#packageJson.name || basename(projectRoot);
+      const type = this.#inferTargetType(this.#packageJson);
+
+      this.#targets.push({
+        name,
+        path: projectRoot,
+        type,
+        language: 'typescript',
+        framework,
+        metadata: { packageJson: this.#packageJson },
+      });
+      this.#depGraph.nodes.push(name);
+    }
+
+    // 添加外部依赖到依赖图
+    this.#addExternalDeps();
+  }
+
+  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() {
+    return this.#depGraph;
+  }
+
+  // ── 内部实现 ──
+
+  #resolveWorkspaces(projectRoot) {
+    const paths = [];
+
+    // npm/yarn workspaces (from package.json)
+    const workspaces = this.#packageJson.workspaces;
+    if (workspaces) {
+      const patterns = Array.isArray(workspaces) ? workspaces : workspaces.packages || [];
+      for (const pattern of patterns) {
+        // 简单 glob 展开: "packages/*" → 列出子目录
+        if (pattern.endsWith('/*') || pattern.endsWith('/**')) {
+          const dir = pattern.replace(/\/\*\*?$/, '');
+          const absDir = resolve(projectRoot, dir);
+          if (existsSync(absDir)) {
+            try {
+              const entries = readdirSync(absDir, { withFileTypes: true });
+              for (const entry of entries) {
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                  paths.push(join(dir, entry.name));
+                }
+              }
+            } catch {
+              /* skip */
+            }
+          }
+        } else {
+          paths.push(pattern);
+        }
+      }
+    }
+
+    // pnpm-workspace.yaml
+    const pnpmWsPath = join(projectRoot, 'pnpm-workspace.yaml');
+    if (paths.length === 0 && existsSync(pnpmWsPath)) {
+      try {
+        const content = readFileSync(pnpmWsPath, 'utf8');
+        const pkgMatches = content.matchAll(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
+        for (const m of pkgMatches) {
+          const pattern = m[1].trim();
+          if (pattern.endsWith('/*') || pattern.endsWith('/**')) {
+            const dir = pattern.replace(/\/\*\*?$/, '');
+            const absDir = resolve(projectRoot, dir);
+            if (existsSync(absDir)) {
+              try {
+                const entries = readdirSync(absDir, { withFileTypes: true });
+                for (const entry of entries) {
+                  if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    paths.push(join(dir, entry.name));
+                  }
+                }
+              } catch {
+                /* skip */
+              }
+            }
+          } else {
+            paths.push(pattern);
+          }
+        }
+      } catch {
+        /* skip */
+      }
+    }
+
+    // lerna.json
+    const lernaPath = join(projectRoot, 'lerna.json');
+    if (paths.length === 0 && existsSync(lernaPath)) {
+      try {
+        const lerna = JSON.parse(readFileSync(lernaPath, 'utf8'));
+        const patterns = lerna.packages || ['packages/*'];
+        for (const pattern of patterns) {
+          if (pattern.endsWith('/*') || pattern.endsWith('/**')) {
+            const dir = pattern.replace(/\/\*\*?$/, '');
+            const absDir = resolve(projectRoot, dir);
+            if (existsSync(absDir)) {
+              try {
+                const entries = readdirSync(absDir, { withFileTypes: true });
+                for (const entry of entries) {
+                  if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    paths.push(join(dir, entry.name));
+                  }
+                }
+              } catch {
+                /* skip */
+              }
+            }
+          } else {
+            paths.push(pattern);
+          }
+        }
+      } catch {
+        /* skip */
+      }
+    }
+
+    return paths;
+  }
+
+  #detectFramework(pkg) {
+    if (!pkg) {
+      return null;
+    }
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+
+    if (deps.next) {
+      return 'nextjs';
+    }
+    if (deps.nuxt || deps.nuxt3) {
+      return 'nuxt';
+    }
+    if (deps['@angular/core']) {
+      return 'angular';
+    }
+    if (deps.svelte) {
+      return 'svelte';
+    }
+    if (deps['react-native']) {
+      return 'react-native';
+    }
+    if (deps.react || deps['react-dom']) {
+      return 'react';
+    }
+    if (deps.vue) {
+      return 'vue';
+    }
+    if (deps['@nestjs/core']) {
+      return 'nestjs';
+    }
+    if (deps.electron) {
+      return 'electron';
+    }
+    if (deps.express) {
+      return 'node-server';
+    }
+    if (deps.fastify) {
+      return 'node-server';
+    }
+    if (deps.koa) {
+      return 'node-server';
+    }
+    if (deps.hono) {
+      return 'node-server';
+    }
+    return null;
+  }
+
+  #inferTargetType(pkg) {
+    if (!pkg) {
+      return 'library';
+    }
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+
+    if (pkg.bin) {
+      return 'executable';
+    }
+    if (deps.jest || deps.mocha || deps.vitest) {
+      // Has test runner but check if it's primary purpose
+      if (pkg.name?.includes('test')) {
+        return 'test';
+      }
+    }
+    if (deps.react || deps.vue || deps['@angular/core'] || deps.svelte) {
+      return 'app';
+    }
+    if (deps.express || deps.fastify || deps.koa || deps['@nestjs/core']) {
+      return 'app';
+    }
+    if (deps.electron) {
+      return 'app';
+    }
+    return 'library';
+  }
+
+  #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) || 'javascript';
+            files.push({
+              name: entry.name,
+              path: fullPath,
+              relativePath: relative(rootDir, fullPath),
+              language: lang,
+            });
+          }
+        }
+      }
+    } catch {
+      /* skip unreadable dirs */
+    }
+  }
+
+  #buildWorkspaceDeps(workspacePaths) {
+    // 收集所有 workspace 包名
+    const nameToPath = new Map();
+    for (const t of this.#targets) {
+      nameToPath.set(t.name, t.path);
+    }
+
+    for (const t of this.#targets) {
+      const pkg = t.metadata?.packageJson;
+      if (!pkg) {
+        continue;
+      }
+      const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+      for (const depName of Object.keys(allDeps)) {
+        if (nameToPath.has(depName)) {
+          this.#depGraph.edges.push({
+            from: t.name,
+            to: depName,
+            type: pkg.devDependencies?.[depName] ? 'dev_depends_on' : 'depends_on',
+          });
+        }
+      }
+    }
+  }
+
+  #addExternalDeps() {
+    if (!this.#packageJson) {
+      return;
+    }
+    const deps = this.#packageJson.dependencies || {};
+    const devDeps = this.#packageJson.devDependencies || {};
+    const rootName = this.#targets[0]?.name;
+    if (!rootName) {
+      return;
+    }
+
+    for (const dep of Object.keys(deps)) {
+      if (!this.#depGraph.nodes.includes(dep)) {
+        this.#depGraph.edges.push({ from: rootName, to: dep, type: 'depends_on' });
+      }
+    }
+    for (const dep of Object.keys(devDeps)) {
+      if (!this.#depGraph.nodes.includes(dep)) {
+        this.#depGraph.edges.push({ from: rootName, to: dep, type: 'dev_depends_on' });
+      }
+    }
+  }
+}

package/lib/core/discovery/ProjectDiscoverer.js

@@ -0,0 +1,93 @@
+/**
+ * @module ProjectDiscoverer
+ * @description 项目结构发现器 — 统一接口定义
+ *
+ * 每个实现负责一种构建系统/包管理器的解析。
+ * Bootstrap Phase 1 通过 DiscovererRegistry 自动选择匹配的实现。
+ */
+
+/**
+ * @typedef {object} DiscoveredTarget
+ * @property {string}   name         — 模块/Target 名称
+ * @property {string}   path         — 模块根目录绝对路径
+ * @property {string}   type         — 'library'|'executable'|'test'|'app'|'package'
+ * @property {string}   [language]   — 主语言
+ * @property {string}   [framework]  — 检测到的框架 (react/vue/express/django/spring/...)
+ * @property {object}   [metadata]   — 构建系统特有元数据
+ */
+
+/**
+ * @typedef {object} DiscoveredFile
+ * @property {string} name         — 文件名
+ * @property {string} path         — 绝对路径
+ * @property {string} relativePath — 相对于项目根的路径
+ * @property {string} language     — 推断语言
+ */
+
+/**
+ * @typedef {object} DependencyEdge
+ * @property {string} from — 源模块名
+ * @property {string} to   — 目标模块名
+ * @property {string} type — 'depends_on'|'dev_depends_on'|'peer_depends_on'
+ */
+
+export class ProjectDiscoverer {
+  /**
+   * 检测此 Discoverer 是否适用于给定项目
+   * @param {string} projectRoot
+   * @returns {Promise<{ match: boolean, confidence: number, reason: string }>}
+   */
+  async detect(projectRoot) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 加载项目结构（解析配置文件、构建依赖图）
+   * @param {string} projectRoot
+   * @returns {Promise<void>}
+   */
+  async load(projectRoot) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 列出所有 Target/模块
+   * @returns {Promise<DiscoveredTarget[]>}
+   */
+  async listTargets() {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 获取指定 Target 下的源码文件列表
+   * @param {DiscoveredTarget|string} target
+   * @returns {Promise<DiscoveredFile[]>}
+   */
+  async getTargetFiles(target) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 获取模块间依赖关系图
+   * @returns {Promise<{ nodes: string[], edges: DependencyEdge[] }>}
+   */
+  async getDependencyGraph() {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Discoverer 标识
+   * @returns {string} 如 'spm', 'node', 'python', 'gradle', 'maven', 'generic'
+   */
+  get id() {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 人类可读名称
+   * @returns {string}
+   */
+  get displayName() {
+    throw new Error('Not implemented');
+  }
+}