@chongyan/autospec 1.0.1

package/plugins/hooks/lib/directory-discovery.js

@@ -0,0 +1,395 @@
+/**
+ * Directory Discovery
+ *
+ * 智能发现项目源码目录
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * 目录发现器
+ * 自动检测项目中的源码目录、技术栈等
+ */
+export class DirectoryDiscovery {
+  constructor(projectDir, config = {}) {
+    this.projectDir = projectDir;
+    this.config = config;
+  }
+
+  /**
+   * 发现所有源码目录
+   */
+  discoverSourceDirectories() {
+    const dirs = [];
+
+    // 1. 从 config.json 的 subsystems 中获取
+    if (this.config.subsystems) {
+      for (const sub of this.config.subsystems) {
+        dirs.push({
+          path: sub.path,
+          type: sub.type,
+          techStack: sub.techStack,
+          language: this.detectLanguage(sub.techStack),
+          build: sub.build,
+          test: sub.test,
+        });
+      }
+    }
+
+    // 2. 自动扫描常见源码目录
+    const commonDirs = this.getCommonSourceDirs();
+    for (const dir of commonDirs) {
+      const fullPath = path.join(this.projectDir, dir);
+      if (fs.existsSync(fullPath) && !dirs.find(d => d.path === dir)) {
+        const techStack = this.detectTechStack(fullPath);
+        dirs.push({
+          path: dir,
+          type: this.inferType(dir),
+          techStack,
+          language: this.detectLanguage(techStack),
+        });
+      }
+    }
+
+    // 3. 扫描根目录的直接子目录（可能是 monorepo）
+    const monorepoDirs = this.detectMonorepoDirs();
+    for (const dir of monorepoDirs) {
+      if (!dirs.find(d => d.path === dir)) {
+        const fullPath = path.join(this.projectDir, dir);
+        dirs.push({
+          path: dir,
+          type: this.inferType(dir),
+          techStack: this.detectTechStack(fullPath),
+          language: null,
+        });
+      }
+    }
+
+    return dirs;
+  }
+
+  /**
+   * 获取常见源码目录名
+   */
+  getCommonSourceDirs() {
+    return [
+      'src',
+      'lib',
+      'app',
+      'server',
+      'backend',
+      'frontend',
+      'api',
+      'web',
+      'client',
+      'mobile',
+      'ml',
+      'ai',
+      'model',
+      'models',
+      'data',
+      'warehouse',
+      'datalake',
+      'pipeline',
+      'etl',
+      'airflow',
+      'lambda',
+      'functions',
+      'services',
+      'packages',
+    ];
+  }
+
+  /**
+   * 检测 monorepo 目录
+   */
+  detectMonorepoDirs() {
+    const dirs = [];
+
+    // 检查是否是 monorepo
+    const lernaPath = path.join(this.projectDir, 'lerna.json');
+    const pnpmWorkspacePath = path.join(this.projectDir, 'pnpm-workspace.yaml');
+    const nxPath = path.join(this.projectDir, 'nx.json');
+
+    if (fs.existsSync(lernaPath) || fs.existsSync(pnpmWorkspacePath) || fs.existsSync(nxPath)) {
+      // 扫描 packages/ 目录
+      const packagesDir = path.join(this.projectDir, 'packages');
+      if (fs.existsSync(packagesDir)) {
+        const entries = fs.readdirSync(packagesDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            dirs.push(`packages/${entry.name}`);
+          }
+        }
+      }
+
+      // 扫描 apps/ 目录
+      const appsDir = path.join(this.projectDir, 'apps');
+      if (fs.existsSync(appsDir)) {
+        const entries = fs.readdirSync(appsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            dirs.push(`apps/${entry.name}`);
+          }
+        }
+      }
+    }
+
+    return dirs;
+  }
+
+  /**
+   * 推断目录类型
+   */
+  inferType(dirName) {
+    const typeMap = {
+      'backend': 'backend',
+      'server': 'backend',
+      'api': 'backend',
+      'frontend': 'frontend',
+      'web': 'frontend',
+      'client': 'frontend',
+      'mobile': 'mobile',
+      'app': 'mobile',
+      'ml': 'ai',
+      'ai': 'ai',
+      'model': 'ai',
+      'models': 'ai',
+      'data': 'data',
+      'warehouse': 'data',
+      'datalake': 'data',
+      'pipeline': 'data',
+      'etl': 'data',
+      'airflow': 'data',
+      'lambda': 'backend',
+      'functions': 'backend',
+      'services': 'backend',
+    };
+
+    // 处理路径中的目录名
+    const parts = dirName.split('/');
+    const lastPart = parts[parts.length - 1].toLowerCase();
+
+    return typeMap[lastPart] || 'unknown';
+  }
+
+  /**
+   * 检测技术栈
+   */
+  detectTechStack(dirPath) {
+    const indicators = [
+      { file: 'package.json', tech: 'Node.js', detector: this.detectNodeFramework.bind(this) },
+      { file: 'pom.xml', tech: 'Java Maven' },
+      { file: 'build.gradle', tech: 'Java Gradle' },
+      { file: 'build.gradle.kts', tech: 'Java Gradle (Kotlin DSL)' },
+      { file: 'go.mod', tech: 'Go' },
+      { file: 'requirements.txt', tech: 'Python' },
+      { file: 'pyproject.toml', tech: 'Python', detector: this.detectPythonFramework.bind(this) },
+      { file: 'Cargo.toml', tech: 'Rust' },
+      { file: 'composer.json', tech: 'PHP' },
+      { file: 'Gemfile', tech: 'Ruby' },
+      { file: 'pubspec.yaml', tech: 'Dart/Flutter' },
+      { file: 'build.sbt', tech: 'Scala' },
+    ];
+
+    for (const ind of indicators) {
+      const filePath = path.join(dirPath, ind.file);
+      if (fs.existsSync(filePath)) {
+        if (ind.detector) {
+          const detailed = ind.detector(filePath);
+          return detailed || ind.tech;
+        }
+        return ind.tech;
+      }
+    }
+
+    return 'Unknown';
+  }
+
+  /**
+   * 检测 Node.js 框架
+   */
+  detectNodeFramework(packageJsonPath) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      if (deps['@nestjs/core']) return 'NestJS';
+      if (deps['express']) return 'Express';
+      if (deps['koa']) return 'Koa';
+      if (deps['fastify']) return 'Fastify';
+      if (deps['next']) return 'Next.js';
+      if (deps['nuxt']) return 'Nuxt.js';
+      if (deps['react']) return 'React';
+      if (deps['vue']) return 'Vue';
+      if (deps['angular']) return 'Angular';
+      if (deps['@angular/core']) return 'Angular';
+      if (deps['svelte']) return 'Svelte';
+
+      return 'Node.js';
+    } catch (e) {
+      return 'Node.js';
+    }
+  }
+
+  /**
+   * 检测 Python 框架
+   */
+  detectPythonFramework(pyprojectPath) {
+    try {
+      const content = fs.readFileSync(pyprojectPath, 'utf-8');
+
+      if (content.includes('django')) return 'Django';
+      if (content.includes('flask')) return 'Flask';
+      if (content.includes('fastapi')) return 'FastAPI';
+      if (content.includes('tornado')) return 'Tornado';
+      if (content.includes('pytorch') || content.includes('torch')) return 'PyTorch';
+      if (content.includes('tensorflow')) return 'TensorFlow';
+
+      return 'Python';
+    } catch (e) {
+      return 'Python';
+    }
+  }
+
+  /**
+   * 从技术栈推断语言
+   */
+  detectLanguage(techStack) {
+    if (!techStack) return null;
+
+    const languageMap = {
+      'Node.js': 'JavaScript',
+      'Express': 'JavaScript',
+      'NestJS': 'TypeScript',
+      'Koa': 'JavaScript',
+      'Fastify': 'JavaScript',
+      'Next.js': 'JavaScript',
+      'Nuxt.js': 'JavaScript',
+      'React': 'JavaScript',
+      'Vue': 'JavaScript',
+      'Angular': 'TypeScript',
+      'Svelte': 'JavaScript',
+      'Java Maven': 'Java',
+      'Java Gradle': 'Java',
+      'Java Gradle (Kotlin DSL)': 'Java',
+      'Go': 'Go',
+      'Python': 'Python',
+      'Django': 'Python',
+      'Flask': 'Python',
+      'FastAPI': 'Python',
+      'PyTorch': 'Python',
+      'TensorFlow': 'Python',
+      'Rust': 'Rust',
+      'PHP': 'PHP',
+      'Ruby': 'Ruby',
+      'Dart/Flutter': 'Dart',
+      'Scala': 'Scala',
+    };
+
+    for (const [key, lang] of Object.entries(languageMap)) {
+      if (techStack.includes(key)) {
+        return lang;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 获取项目的所有配置文件
+   */
+  discoverConfigFiles() {
+    const configs = [];
+
+    const configPatterns = [
+      { name: 'package.json', type: 'npm' },
+      { name: 'requirements.txt', type: 'pip' },
+      { name: 'pyproject.toml', type: 'pip' },
+      { name: 'pom.xml', type: 'maven' },
+      { name: 'build.gradle', type: 'gradle' },
+      { name: 'go.mod', type: 'go' },
+      { name: 'Cargo.toml', type: 'cargo' },
+      { name: 'composer.json', type: 'composer' },
+      { name: 'Gemfile', type: 'bundler' },
+      { name: 'docker-compose.yml', type: 'docker-compose' },
+      { name: 'docker-compose.yaml', type: 'docker-compose' },
+      { name: 'Dockerfile', type: 'docker' },
+      { name: '.env', type: 'env' },
+      { name: '.env.example', type: 'env-example' },
+      { name: 'k8s/', type: 'kubernetes' },
+      { name: 'kubernetes/', type: 'kubernetes' },
+      { name: '.github/workflows/', type: 'github-actions' },
+      { name: '.gitlab-ci.yml', type: 'gitlab-ci' },
+      { name: 'Jenkinsfile', type: 'jenkins' },
+    ];
+
+    for (const pattern of configPatterns) {
+      const fullPath = path.join(this.projectDir, pattern.name);
+      if (fs.existsSync(fullPath)) {
+        configs.push({
+          name: pattern.name,
+          type: pattern.type,
+          path: pattern.name,
+        });
+      }
+    }
+
+    return configs;
+  }
+
+  /**
+   * 获取项目的环境变量文件
+   */
+  discoverEnvFiles() {
+    const envFiles = [];
+
+    const envPatterns = [
+      '.env',
+      '.env.local',
+      '.env.development',
+      '.env.test',
+      '.env.staging',
+      '.env.production',
+      '.env.example',
+    ];
+
+    for (const pattern of envPatterns) {
+      const fullPath = path.join(this.projectDir, pattern);
+      if (fs.existsSync(fullPath)) {
+        envFiles.push({
+          name: pattern,
+          path: pattern,
+        });
+      }
+    }
+
+    return envFiles;
+  }
+
+  /**
+   * 分析项目结构
+   */
+  analyzeProjectStructure() {
+    const sourceDirs = this.discoverSourceDirectories();
+    const configFiles = this.discoverConfigFiles();
+    const envFiles = this.discoverEnvFiles();
+
+    return {
+      sourceDirs,
+      configFiles,
+      envFiles,
+      isMonorepo: sourceDirs.some(d => d.path.startsWith('packages/') || d.path.startsWith('apps/')),
+      hasBackend: sourceDirs.some(d => d.type === 'backend'),
+      hasFrontend: sourceDirs.some(d => d.type === 'frontend'),
+      hasMobile: sourceDirs.some(d => d.type === 'mobile'),
+      hasAI: sourceDirs.some(d => d.type === 'ai'),
+      hasData: sourceDirs.some(d => d.type === 'data'),
+      techStacks: [...new Set(sourceDirs.map(d => d.techStack).filter(Boolean))],
+      languages: [...new Set(sourceDirs.map(d => d.language).filter(Boolean))],
+    };
+  }
+}
+
+export default DirectoryDiscovery;