rules-enforcer 1.0.0

package/detector/project-detector.js

@@ -0,0 +1,710 @@
+/**
+ * Project Detector Plugin for Trae IDE
+ * 插件路径: .trae/plugins/project-detector/
+ * 功能: 只读扫描项目结构，识别技术栈、目录拓扑、已有组件
+ * 约束: 全程只读，不修改项目任何源码与配置
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ProjectDetector {
+  constructor(projectRoot) {
+    if (!projectRoot || typeof projectRoot !== 'string') {
+      throw new Error('[ProjectDetector] 项目路径参数无效');
+    }
+
+    this.root = path.resolve(projectRoot);
+    
+    if (!fs.existsSync(this.root) || !fs.statSync(this.root).isDirectory()) {
+      throw new Error(`[ProjectDetector] 项目路径不存在或不是目录: ${this.root}`);
+    }
+
+    this.techStack = [];
+    this.structure = null;
+    this.fullTopology = [];
+    this.existingComponents = {
+      mcp: [],
+      agents: [],
+      rules: []
+    };
+    this.fileErrors = [];
+  }
+
+  /**
+   * 记录文件读取异常
+   */
+  logFileError(filePath, error, context) {
+    this.fileErrors.push({
+      file: filePath,
+      error: String(error),
+      context: context,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * 扫描技术栈
+   */
+  scanTechStack() {
+    const checks = [
+      { file: 'package.json', detect: (content) => this.detectNodeJS(content) },
+      { file: 'tsconfig.json', detect: () => 'TypeScript' },
+      { file: 'requirements.txt', detect: () => 'Python' },
+      { file: 'go.mod', detect: () => 'Go' },
+      { file: 'Cargo.toml', detect: () => 'Rust' },
+      { file: 'pom.xml', detect: () => 'Maven/Java' }
+    ];
+
+    for (const check of checks) {
+      const filePath = path.join(this.root, check.file);
+      if (fs.existsSync(filePath)) {
+        try {
+          const content = fs.readFileSync(filePath, 'utf8');
+          const detected = check.detect(content);
+          if (detected) {
+            const stacks = Array.isArray(detected) ? detected : [detected];
+            for (const stack of stacks) {
+              if (stack && !this.techStack.includes(stack)) {
+                this.techStack.push(stack);
+              }
+            }
+          }
+        } catch (e) {
+          this.logFileError(check.file, e, 'scanTechStack');
+        }
+      }
+    }
+
+    return this.techStack;
+  }
+
+  /**
+   * 解析Node.js项目依赖
+   */
+  detectNodeJS(pkgContent) {
+    try {
+      const pkg = JSON.parse(pkgContent);
+      const deps = pkg.dependencies || {};
+      const frameworks = [];
+
+      if (deps.express || deps['express-']) frameworks.push('Express.js');
+      if (deps.koa) frameworks.push('Koa');
+      if (deps.fastify) frameworks.push('Fastify');
+      if (deps.next) frameworks.push('Next.js');
+      if (deps.nuxt) frameworks.push('Nuxt.js');
+      if (deps.vite) frameworks.push('Vite');
+      if (deps.webpack) frameworks.push('Webpack');
+      if (deps.react) frameworks.push('React');
+      if (deps.vue) frameworks.push('Vue.js');
+      if (deps.sequelize) frameworks.push('Sequelize/ORM');
+      if (deps.typeorm) frameworks.push('TypeORM');
+      if (deps['better-sqlite3'] || deps.sqlite3) frameworks.push('SQLite');
+      if (deps.mongoose) frameworks.push('MongoDB/Mongoose');
+
+      return ['Node.js', ...frameworks];
+    } catch {
+      return ['Node.js'];
+    }
+  }
+
+  /**
+   * 扫描目录结构
+   */
+  scanDirectoryStructure(maxDepth = 4) {
+    this.fullTopology = [];
+
+    try {
+      this.structure = this._scanDir(this.root, 0, maxDepth);
+    } catch (e) {
+      this.logFileError(this.root, e, 'scanDirectoryStructure');
+      this.structure = null;
+    }
+
+    return this.structure;
+  }
+
+  /**
+   * 递归扫描目录
+   */
+  _scanDir(dir, depth, maxDepth) {
+    if (depth > maxDepth) return null;
+
+    const name = path.basename(dir);
+    const relativePath = path.relative(this.root, dir) || '.';
+
+    const node = {
+      name,
+      path: relativePath,
+      depth,
+      type: this.categorizeDir(name),
+      files: [],
+      dirs: []
+    };
+
+    this.fullTopology.push({
+      path: relativePath,
+      depth,
+      type: 'directory',
+      category: node.type
+    });
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+          continue;
+        }
+
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          const childNode = this._scanDir(fullPath, depth + 1, maxDepth);
+          if (childNode) {
+            node.dirs.push(childNode);
+          }
+        } else {
+          const fileInfo = {
+            name: entry.name,
+            path: path.relative(this.root, fullPath),
+            type: this.categorizeFile(entry.name)
+          };
+          node.files.push(fileInfo);
+
+          this.fullTopology.push({
+            path: fileInfo.path,
+            depth: depth + 1,
+            type: 'file',
+            category: fileInfo.type
+          });
+        }
+      }
+    } catch (e) {
+      this.logFileError(dir, e, `_scanDir depth=${depth}`);
+    }
+
+    return node;
+  }
+
+  /**
+   * 目录分类
+   */
+  categorizeDir(name) {
+    const categories = {
+      'src': 'business_code',
+      'lib': 'business_code',
+      'app': 'business_code',
+      'pages': 'frontend_pages',
+      'components': 'frontend_components',
+      'views': 'frontend_views',
+      'test': 'test_directory',
+      'tests': 'test_directory',
+      '__tests__': 'test_directory',
+      'spec': 'test_directory',
+      'scripts': 'deployment_scripts',
+      'config': 'configuration',
+      'configs': 'configuration',
+      'docs': 'documentation',
+      'public': 'static_assets',
+      'static': 'static_assets',
+      'dist': 'build_output',
+      'build': 'build_output',
+      '.trae': 'trae_config',
+      '.claude': 'claude_config',
+      'database': 'data_storage',
+      'mcp': 'mcp_services',
+      'rules': 'rules_engine',
+      'utils': 'utilities',
+      'middleware': 'middleware',
+      'routes': 'routing'
+    };
+    return categories[name] || 'other';
+  }
+
+  /**
+   * 文件分类
+   */
+  categorizeFile(name) {
+    if (name.endsWith('.test.js') || name.endsWith('.spec.js')) return 'test_file';
+    if (name.endsWith('.test.ts') || name.endsWith('.spec.ts')) return 'test_file';
+    if (name === 'package.json') return 'dependency_manifest';
+    if (name === 'AGENTS.md' || name === 'CLAUDE.md') return 'trae_config';
+    if (name === 'user_rules.md') return 'rules_L1';
+    if (name === 'project_rules.md') return 'rules_L2';
+    if (name.endsWith('.yml') || name.endsWith('.yaml')) return 'config_yaml';
+    if (name.endsWith('.json')) return 'config_json';
+    if (name.endsWith('.js') || name.endsWith('.ts')) return 'source_code';
+    if (name.endsWith('.md')) return 'documentation';
+    return 'other';
+  }
+
+  /**
+   * 扫描MCP服务
+   */
+  scanMCP() {
+    const mcpConfigPaths = [
+      path.join(this.root, '.trae', 'mcp', 'mcp.json'),
+      path.join(this.root, '.trae', 'mcp.json'),
+      path.join(process.env.APPDATA || '', 'Trae', 'User', 'globalStorage', 'mcp.json')
+    ];
+
+    for (const configPath of mcpConfigPaths) {
+      if (fs.existsSync(configPath)) {
+        try {
+          const content = fs.readFileSync(configPath, 'utf8');
+          const config = JSON.parse(content);
+          if (config.mcpServers) {
+            this.existingComponents.mcp = Object.keys(config.mcpServers);
+            break;
+          }
+        } catch (e) {
+          this.logFileError(configPath, e, 'scanMCP');
+        }
+      }
+    }
+
+    return this.existingComponents.mcp;
+  }
+
+  /**
+   * 扫描Agent配置
+   */
+  scanAgents() {
+    const rootAgentsPath = path.join(this.root, 'AGENTS.md');
+    if (fs.existsSync(rootAgentsPath)) {
+      this.existingComponents.agents.push({
+        name: 'AGENTS.md',
+        path: 'AGENTS.md',
+        type: 'root_config'
+      });
+    }
+
+    const agentsDir = path.join(this.root, '.trae', 'agents');
+    if (fs.existsSync(agentsDir)) {
+      try {
+        const files = fs.readdirSync(agentsDir);
+        for (const file of files) {
+          if (file.endsWith('.md')) {
+            this.existingComponents.agents.push({
+              name: file,
+              path: path.join('.trae', 'agents', file),
+              type: 'sub_agent'
+            });
+          }
+        }
+      } catch (e) {
+        this.logFileError(agentsDir, e, 'scanAgents');
+      }
+    }
+
+    return this.existingComponents.agents;
+  }
+
+  /**
+   * 扫描规则文件
+   */
+  scanRules() {
+    const rulesDir = path.join(this.root, '.trae', 'rules');
+
+    if (!fs.existsSync(rulesDir)) {
+      this.fileErrors.push({
+        file: rulesDir,
+        error: '目录不存在',
+        context: 'scanRules',
+        timestamp: new Date().toISOString()
+      });
+      return this.existingComponents.rules;
+    }
+
+    // L1/L2目录规则
+    const levelRules = [
+      { dir: 'L1', level: 'L1', suffix: '-user-rules.md' },
+      { dir: 'L2', level: 'L2', suffix: '-project-rules.md' }
+    ];
+
+    for (const rule of levelRules) {
+      const levelDir = path.join(rulesDir, rule.dir);
+      if (fs.existsSync(levelDir)) {
+        try {
+          const files = fs.readdirSync(levelDir);
+          for (const file of files) {
+            if (file.endsWith('.md')) {
+              const filePath = path.join(levelDir, file);
+              try {
+                fs.readFileSync(filePath, 'utf8');
+                this.existingComponents.rules.push({
+                  name: file,
+                  path: path.join('.trae', 'rules', rule.dir, file),
+                  level: rule.level
+                });
+              } catch (readErr) {
+                this.logFileError(filePath, readErr, `scanRules/${rule.dir}/read`);
+              }
+            }
+          }
+        } catch (e) {
+          this.fileErrors.push({
+            file: levelDir,
+            error: e.message,
+            context: `scanRules/${rule.dir}`,
+            timestamp: new Date().toISOString()
+          });
+        }
+      }
+    }
+
+    const l3Dirs = ['L3/RZero', 'custom_config'];
+    for (const l3Dir of l3Dirs) {
+      const l3Path = path.join(rulesDir, l3Dir);
+
+      if (!fs.existsSync(l3Path)) {
+        this.fileErrors.push({
+          file: l3Path,
+          error: 'L3子目录不存在',
+          context: `scanRules/${l3Dir}`,
+          timestamp: new Date().toISOString()
+        });
+        continue;
+      }
+
+      try {
+        const files = fs.readdirSync(l3Path);
+        for (const file of files) {
+          if (file.endsWith('.md') || file.endsWith('.yml') || file.endsWith('.yaml')) {
+            const filePath = path.join(l3Path, file);
+            try {
+              fs.readFileSync(filePath, 'utf8');
+              this.existingComponents.rules.push({
+                name: file,
+                path: path.join('.trae', 'rules', l3Dir, file),
+                level: 'L3',
+                module: l3Dir.includes('RZero') ? 'RZero' : 'custom_config',
+                readable: true
+              });
+            } catch (readErr) {
+              this.logFileError(filePath, readErr, `scanRules/${l3Dir}/read`);
+            }
+          }
+        }
+      } catch (e) {
+        this.fileErrors.push({
+          file: l3Path,
+          error: e.message,
+          context: `scanRules/${l3Dir}/scan`,
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+
+    const attnPath = path.join(rulesDir, 'attention_optim_rule.md');
+    if (fs.existsSync(attnPath)) {
+      this.existingComponents.rules.push({
+        name: 'attention_optim_rule.md',
+        path: path.join('.trae', 'rules', 'attention_optim_rule.md'),
+        level: 'custom',
+        module: 'attention_optimization'
+      });
+    }
+
+    return this.existingComponents.rules;
+  }
+
+  /**
+   * 生成拓扑树字符串
+   */
+  generateTopologyTree() {
+    const lines = [];
+
+    const printNode = (node, prefix = '', isLast = true) => {
+      const connector = isLast ? '└── ' : '├── ';
+      const newPrefix = prefix + (isLast ? '    ' : '│   ');
+
+      lines.push(`${prefix}${connector}${node.name}/ [${node.type}]`);
+
+      if (node.files) {
+        for (let i = 0; i < node.files.length; i++) {
+          const file = node.files[i];
+          const fileConnector = i === node.files.length - 1 && (!node.dirs || node.dirs.length === 0) ? '└── ' : '├── ';
+          lines.push(`${newPrefix}${fileConnector}${file.name} [${file.type}]`);
+        }
+      }
+
+      if (node.dirs) {
+        for (let i = 0; i < node.dirs.length; i++) {
+          printNode(node.dirs[i], newPrefix, i === node.dirs.length - 1);
+        }
+      }
+    };
+
+    if (this.structure) {
+      lines.push(`${this.structure.name}/ [${this.structure.type}]`);
+      for (let i = 0; i < this.structure.dirs.length; i++) {
+        printNode(this.structure.dirs[i], '', i === this.structure.dirs.length - 1);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * 执行完整扫描
+   */
+  scan() {
+    console.log('[ProjectDetector] ========== 项目探测开始 ==========');
+    console.log(`[ProjectDetector] 项目路径: ${this.root}`);
+
+    this.techStack = this.scanTechStack();
+    console.log(`[ProjectDetector] 技术栈: ${this.techStack.join(', ') || '未识别'}`);
+
+    this.scanDirectoryStructure();
+    console.log(`[ProjectDetector] 目录拓扑: ${this.fullTopology.length}个节点`);
+
+    this.scanMCP();
+    console.log(`[ProjectDetector] MCP服务: ${this.existingComponents.mcp.join(', ') || '无'}`);
+
+    this.scanAgents();
+    console.log(`[ProjectDetector] Agent配置: ${this.existingComponents.agents.length}个`);
+
+    this.scanRules();
+    console.log(`[ProjectDetector] 规则文件: ${this.existingComponents.rules.length}个`);
+
+    if (this.fileErrors.length > 0) {
+      console.log(`[ProjectDetector] 文件异常: ${this.fileErrors.length}个`);
+    }
+
+    console.log('[ProjectDetector] ========== 探测完成 ==========');
+
+    return this.getReport();
+  }
+
+  /**
+   * 获取报告
+   */
+  getReport() {
+    return {
+      projectRoot: this.root,
+      techStack: this.techStack,
+      structure: this.structure,
+      fullTopology: this.fullTopology,
+      topologyTree: this.generateTopologyTree(),
+      existingComponents: this.existingComponents,
+      fileErrors: this.fileErrors,
+      stats: {
+        mcpCount: this.existingComponents.mcp.length,
+        agentCount: this.existingComponents.agents.length,
+        ruleCount: this.existingComponents.rules.length,
+        l1Rules: this.existingComponents.rules.filter(r => r.level === 'L1').length,
+        l2Rules: this.existingComponents.rules.filter(r => r.level === 'L2').length,
+        l3Rules: this.existingComponents.rules.filter(r => r.level === 'L3').length,
+        customRules: this.existingComponents.rules.filter(r => r.level === 'custom').length,
+        fileErrorCount: this.fileErrors.length,
+        topologyNodeCount: this.fullTopology.length
+      },
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * 输出给rules-engine使用
+   */
+  exportForRulesEngine() {
+    return {
+      tech_features: {
+        is_nodejs: this.techStack.includes('Node.js'),
+        is_typescript: this.techStack.includes('TypeScript'),
+        is_express: this.techStack.includes('Express.js'),
+        is_react: this.techStack.includes('React'),
+        is_vue: this.techStack.includes('Vue.js'),
+        is_database: this.techStack.some(t => t.includes('SQLite') || t.includes('MongoDB'))
+      },
+      existing_mcp: this.existingComponents.mcp,
+      existing_agents: this.existingComponents.agents.map(a => a.name),
+      existing_rules_levels: {
+        L1: this.existingComponents.rules.filter(r => r.level === 'L1').length,
+        L2: this.existingComponents.rules.filter(r => r.level === 'L2').length,
+        L3: this.existingComponents.rules.filter(r => r.level === 'L3').length
+      },
+      complexity: this.estimateComplexity(),
+      fileErrors: this.fileErrors
+    };
+  }
+
+  /**
+   * 评估复杂度
+   */
+  estimateComplexity() {
+    let score = 0;
+    score += this.techStack.length * 5;
+    score += Math.min(this.fullTopology.length, 100);
+    score += this.existingComponents.mcp.length * 10;
+    score += this.existingComponents.agents.length * 5;
+    score += this.existingComponents.rules.length * 3;
+
+    if (score < 30) return 'simple';
+    if (score < 80) return 'medium';
+    return 'complex';
+  }
+
+  /**
+   * 对接知识库，获取配置推荐
+   */
+  getKnowledgeBaseRecommendations() {
+    try {
+      const { KnowledgeBase } = require('./knowledge-base/index.js');
+      const kb = new KnowledgeBase(path.join(__dirname, 'knowledge-base'));
+      return kb.generateRecommendations(this.getReport());
+    } catch (e) {
+      return {
+        error: `知识库对接失败: ${e.message}`,
+        recommendations: null
+      };
+    }
+  }
+
+  /**
+   * 打印知识库推荐结果
+   */
+  printKnowledgeRecommendations() {
+    const recommendations = this.getKnowledgeBaseRecommendations();
+    
+    if (recommendations.error) {
+      console.log(`[ProjectDetector] ⚠️ ${recommendations.error}`);
+      return;
+    }
+
+    console.log('\n[ProjectDetector] ========== 知识库推荐 ==========');
+    
+    const { recommendations: rec, summary } = recommendations;
+    
+    console.log('\n📦 推荐新增MCP服务:');
+    if (rec.newMcpServices.length === 0) {
+      console.log('   无需新增MCP服务（已有服务已足够）');
+    } else {
+      for (const mcp of rec.newMcpServices) {
+        console.log(`   - ${mcp.name} (${mcp.type}) - 匹配度: ${mcp.matchScore}`);
+      }
+    }
+
+    console.log('\n📋 推荐新增规则:');
+    if (rec.newRules.length === 0) {
+      console.log('   无需新增规则（已有规则已足够）');
+    } else {
+      for (const rule of rec.newRules) {
+        console.log(`   - ${rule.name} [${rule.level}] - ${rule.description}`);
+      }
+    }
+
+    console.log('\n👤 推荐Agent配置:');
+    if (rec.agentProfile) {
+      console.log(`   ${rec.agentProfile.name}`);
+      console.log(`   MCP: ${rec.agentProfile.recommendedMcp.join(', ')}`);
+      console.log(`   规则: ${rec.agentProfile.recommendedRules.join(', ')}`);
+    } else {
+      console.log('   无Agent推荐');
+    }
+
+    console.log('\n===========================================');
+    return recommendations;
+  }
+
+  /**
+   * 对接决策引擎，获取最优配置决策
+   */
+  getDecisionEngineResult() {
+    try {
+      const { DecisionEngine } = require('./decision-engine/index.js');
+      const { KnowledgeBase } = require('./knowledge-base/index.js');
+      
+      const engine = new DecisionEngine();
+      const kb = new KnowledgeBase(path.join(__dirname, 'knowledge-base'));
+      kb.load();
+      
+      return engine.decide(kb, this.getReport());
+    } catch (e) {
+      return {
+        error: `决策引擎对接失败: ${e.message}`,
+        decision: null
+      };
+    }
+  }
+
+  /**
+   * 打印决策引擎结果
+   */
+  printDecisionResult() {
+    const result = this.getDecisionEngineResult();
+    
+    if (result.error) {
+      console.log(`[ProjectDetector] ⚠️ ${result.error}`);
+      return;
+    }
+
+    const { DecisionEngine } = require('./decision-engine/index.js');
+    const engine = new DecisionEngine();
+    engine.printDecision(result);
+
+    // 自动调用渲染引擎生成配置 - 已禁用，避免自动生成YML与MD冲突
+    // this.executeRender(result);
+
+    return result;
+  }
+
+  /**
+   * 执行渲染引擎，生成配置
+   */
+  executeRender(decisionResult) {
+    try {
+      const { RenderEngine } = require('./render-engine/index.js');
+      const renderEngine = new RenderEngine({ outputDir: this.projectRoot });
+      renderEngine.render(decisionResult);
+    } catch (e) {
+      console.log(`[ProjectDetector] ⚠️ 渲染引擎调用失败: ${e.message}`);
+    }
+  }
+}
+
+// 导出
+module.exports = { ProjectDetector };
+
+// CLI入口
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  let projectRoot;
+
+  if (args.length === 0) {
+    projectRoot = process.cwd();
+    console.log('[ProjectDetector] 未指定项目路径，使用当前目录:', projectRoot);
+  } else if (args[0] && typeof args[0] === 'string' && args[0].trim() !== '') {
+    projectRoot = path.resolve(args[0].trim());
+  } else {
+    console.error('[ProjectDetector] 错误: 无效的项目路径参数');
+    console.log('用法: node project-detector.js [项目路径]');
+    process.exit(1);
+  }
+
+  try {
+    const detector = new ProjectDetector(projectRoot);
+    const report = detector.scan();
+
+    console.log('\n========== 探测报告 ==========');
+    console.log(JSON.stringify(report, null, 2));
+
+    console.log('\n========== 目录拓扑树 ==========');
+    console.log(report.topologyTree);
+
+    if (report.fileErrors.length > 0) {
+      console.log('\n========== 文件异常日志 ==========');
+      console.log(JSON.stringify(report.fileErrors, null, 2));
+    }
+
+    // 输出知识库推荐
+    detector.printKnowledgeRecommendations();
+
+    // 输出决策引擎结果
+    detector.printDecisionResult();
+  } catch (err) {
+    console.error('[ProjectDetector] 扫描失败:', err.message);
+    process.exit(1);
+  }
+}