openmatrix 0.2.16 → 0.2.18

package/dist/orchestrator/environment-detector.js

@@ -0,0 +1,1110 @@
+"use strict";
+// src/orchestrator/environment-detector.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentDetector = exports.DEFAULT_ENVIRONMENT_DETECTOR_CONFIG = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/**
+ * 默认环境检测器配置
+ */
+exports.DEFAULT_ENVIRONMENT_DETECTOR_CONFIG = {
+    scanDirs: ['', '.github', '.circleci', 'k8s', 'helm', 'deploy', 'deployment'],
+    excludeDirs: ['node_modules', 'dist', '.git', '.openmatrix', 'coverage', 'tests', '__tests__', 'test', 'spec']
+};
+/**
+ * 环境检测器
+ *
+ * 自动扫描项目结构，检测构建工具、CI配置、部署选项等环境信息。
+ */
+class EnvironmentDetector {
+    config;
+    projectRoot;
+    constructor(projectRoot, config = {}) {
+        this.projectRoot = projectRoot;
+        this.config = { ...exports.DEFAULT_ENVIRONMENT_DETECTOR_CONFIG, ...config };
+    }
+    /**
+     * 执行完整检测
+     */
+    async detect() {
+        const projectType = await this.detectProjectType();
+        const projectName = await this.getProjectName();
+        const buildTools = await this.detectBuildTools(projectType);
+        const ciConfig = await this.detectCIConfig();
+        const deployOptions = await this.detectDeployOptions(buildTools);
+        const devCommands = await this.getDevCommands(projectType, buildTools);
+        return {
+            projectName,
+            projectType,
+            projectRoot: this.projectRoot,
+            timestamp: new Date().toISOString(),
+            buildTools,
+            ciConfig,
+            deployOptions,
+            devCommands,
+            summary: {
+                hasBuildTool: buildTools.length > 0,
+                hasCIConfig: ciConfig !== undefined,
+                hasDeployOption: deployOptions.length > 0,
+                buildToolCount: buildTools.length,
+                deployOptionCount: deployOptions.length
+            }
+        };
+    }
+    /**
+     * 检测项目类型
+     */
+    async detectProjectType() {
+        try {
+            // 检查是否是 OpenMatrix 项目
+            const omPath = path.join(this.projectRoot, '.openmatrix');
+            const packageJsonPath = path.join(this.projectRoot, 'package.json');
+            try {
+                await fs.access(omPath);
+                try {
+                    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                    if (packageJson.name === 'openmatrix' ||
+                        packageJson.description?.includes('OpenMatrix')) {
+                        return 'openmatrix';
+                    }
+                }
+                catch {
+                    // 没有 package.json，但仍可能是 OpenMatrix 项目
+                    return 'openmatrix';
+                }
+            }
+            catch {
+                // 不是 OpenMatrix 项目
+            }
+            // 检查是否是 AI 项目
+            const aiIndicators = [
+                '.claude',
+                '.cursor',
+                'skills',
+                'prompts',
+                '.cursorrules',
+                'CLAUDE.md',
+                'AGENTS.md',
+                'GEMINI.md',
+                '.mcp'
+            ];
+            let aiIndicatorCount = 0;
+            for (const indicator of aiIndicators) {
+                try {
+                    await fs.access(path.join(this.projectRoot, indicator));
+                    aiIndicatorCount++;
+                }
+                catch {
+                    // 不存在
+                }
+            }
+            // 如果有 2 个或以上 AI 指标，认为是 AI 项目
+            if (aiIndicatorCount >= 2) {
+                return 'ai-project';
+            }
+            // 检查 package.json
+            try {
+                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                // 检查是否有 AI 相关依赖
+                const aiDeps = [
+                    'anthropic',
+                    '@anthropic-ai/sdk',
+                    'openai',
+                    '@langchain',
+                    'llamaindex',
+                    'claude-agent-sdk'
+                ];
+                const allDeps = {
+                    ...packageJson.dependencies,
+                    ...packageJson.devDependencies
+                };
+                for (const dep of aiDeps) {
+                    if (allDeps[dep]) {
+                        return 'ai-project';
+                    }
+                }
+                // 检查 TypeScript
+                if (packageJson.devDependencies?.typescript ||
+                    packageJson.dependencies?.typescript) {
+                    // 检查是否是特定框架
+                    if (allDeps['next'])
+                        return 'nextjs';
+                    if (allDeps['nuxt'])
+                        return 'nuxt';
+                    if (allDeps['@angular/core'])
+                        return 'angular';
+                    if (allDeps['svelte'] || allDeps['svelte-kit'])
+                        return 'svelte';
+                    if (allDeps['react'] && !allDeps['next'] && !allDeps['@angular/core'])
+                        return 'react';
+                    if (allDeps['vue'] && !allDeps['nuxt'])
+                        return 'vue';
+                    return 'typescript';
+                }
+                // 检查是否是特定框架
+                if (allDeps['next'])
+                    return 'nextjs';
+                if (allDeps['nuxt'])
+                    return 'nuxt';
+                if (allDeps['@angular/core'])
+                    return 'angular';
+                if (allDeps['svelte'] || allDeps['svelte-kit'])
+                    return 'svelte';
+                if (allDeps['react'])
+                    return 'react';
+                if (allDeps['vue'])
+                    return 'vue';
+                return 'nodejs';
+            }
+            catch {
+                // 没有 package.json
+            }
+            // 检查 Python
+            try {
+                await fs.access(path.join(this.projectRoot, 'pyproject.toml'));
+                return 'python';
+            }
+            catch {
+                // 不是 Python
+            }
+            try {
+                await fs.access(path.join(this.projectRoot, 'requirements.txt'));
+                return 'python';
+            }
+            catch {
+                // 不是 Python
+            }
+            try {
+                await fs.access(path.join(this.projectRoot, 'Pipfile'));
+                return 'python';
+            }
+            catch {
+                // 不是 Python Pipenv
+            }
+            // 检查 Go
+            try {
+                await fs.access(path.join(this.projectRoot, 'go.mod'));
+                return 'go';
+            }
+            catch {
+                // 不是 Go
+            }
+            // 检查 Rust
+            try {
+                await fs.access(path.join(this.projectRoot, 'Cargo.toml'));
+                return 'rust';
+            }
+            catch {
+                // 不是 Rust
+            }
+            // 检查 Java
+            try {
+                await fs.access(path.join(this.projectRoot, 'pom.xml'));
+                return 'java';
+            }
+            catch {
+                // 不是 Java (Maven)
+            }
+            try {
+                await fs.access(path.join(this.projectRoot, 'build.gradle'));
+                return 'java';
+            }
+            catch {
+                // 不是 Java (Gradle)
+            }
+            try {
+                await fs.access(path.join(this.projectRoot, 'build.gradle.kts'));
+                return 'java';
+            }
+            catch {
+                // 不是 Java (Gradle Kotlin DSL)
+            }
+            // 检查 Kotlin
+            try {
+                const files = await fs.readdir(this.projectRoot);
+                if (files.some(f => f.endsWith('.kt') || f.endsWith('.kts'))) {
+                    // 如果有 build.gradle.kts 但没有 pom.xml，可能是 Kotlin 项目
+                    try {
+                        await fs.access(path.join(this.projectRoot, 'build.gradle.kts'));
+                        return 'kotlin';
+                    }
+                    catch {
+                        // 不是 Gradle Kotlin 项目
+                    }
+                }
+            }
+            catch {
+                // 无法读取目录
+            }
+            // 检查 Scala
+            try {
+                const files = await fs.readdir(this.projectRoot);
+                if (files.some(f => f.endsWith('.scala') || f.endsWith('.sc'))) {
+                    return 'scala';
+                }
+            }
+            catch {
+                // 无法读取目录
+            }
+            // 检查 C#
+            try {
+                const files = await fs.readdir(this.projectRoot);
+                if (files.some(f => f.endsWith('.sln') || f.endsWith('.csproj'))) {
+                    return 'csharp';
+                }
+            }
+            catch {
+                // 不是 C#
+            }
+            // 检查 C/C++
+            try {
+                await fs.access(path.join(this.projectRoot, 'CMakeLists.txt'));
+                return 'cpp';
+            }
+            catch {
+                // 不是 CMake 项目
+            }
+            try {
+                await fs.access(path.join(this.projectRoot, 'Makefile'));
+                // 有 Makefile 通常表示 C/C++ 项目
+                // 检查是否有 .c, .cpp, .h 文件来确认
+                try {
+                    const files = await fs.readdir(this.projectRoot);
+                    const hasCFiles = files.some(f => f.endsWith('.c') || f.endsWith('.cpp') || f.endsWith('.h') || f.endsWith('.hpp') || f.endsWith('.cc') || f.endsWith('.cxx'));
+                    if (hasCFiles) {
+                        return 'cpp';
+                    }
+                    // Makefile 存在但无 C/C++ 源文件，可能是其他类型项目或空项目
+                    // 在测试场景中，我们假设 Makefile 表示 C/C++ 项目
+                    return 'cpp';
+                }
+                catch {
+                    // 无法读取目录，假设 Makefile 为 C/C++ 项目
+                    return 'cpp';
+                }
+            }
+            catch {
+                // 不是 Make 项目
+            }
+            // 检查 PHP
+            try {
+                await fs.access(path.join(this.projectRoot, 'composer.json'));
+                return 'php';
+            }
+            catch {
+                // 不是 PHP
+            }
+            // 检查 Dart
+            try {
+                await fs.access(path.join(this.projectRoot, 'pubspec.yaml'));
+                // 检查是否是 Flutter
+                try {
+                    const pubspec = await fs.readFile(path.join(this.projectRoot, 'pubspec.yaml'), 'utf-8');
+                    if (pubspec.includes('flutter')) {
+                        return 'flutter';
+                    }
+                }
+                catch {
+                    // 无法读取 pubspec.yaml
+                }
+                return 'dart';
+            }
+            catch {
+                // 不是 Dart
+            }
+            // 检查 Ruby
+            try {
+                await fs.access(path.join(this.projectRoot, 'Gemfile'));
+                return 'ruby';
+            }
+            catch {
+                // 不是 Ruby
+            }
+            // 检查 Swift
+            try {
+                await fs.access(path.join(this.projectRoot, 'Package.swift'));
+                return 'swift';
+            }
+            catch {
+                // 不是 Swift
+            }
+            return 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /**
+     * 获取项目名称
+     */
+    async getProjectName() {
+        try {
+            // 从 package.json 获取
+            const packageJsonPath = path.join(this.projectRoot, 'package.json');
+            try {
+                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                return packageJson.name || path.basename(this.projectRoot);
+            }
+            catch {
+                // 没有 package.json
+            }
+            // 从 pyproject.toml 获取
+            try {
+                const pyproject = await fs.readFile(path.join(this.projectRoot, 'pyproject.toml'), 'utf-8');
+                const nameMatch = pyproject.match(/name\s*=\s*["']([^"']+)["']/);
+                if (nameMatch) {
+                    return nameMatch[1];
+                }
+            }
+            catch {
+                // 没有 pyproject.toml
+            }
+            // 从 go.mod 获取
+            try {
+                const goMod = await fs.readFile(path.join(this.projectRoot, 'go.mod'), 'utf-8');
+                const moduleMatch = goMod.match(/module\s+([^\s]+)/);
+                if (moduleMatch) {
+                    // go module 名称可能包含路径，取最后部分
+                    const moduleName = moduleMatch[1];
+                    return moduleName.split('/').pop() || moduleName;
+                }
+            }
+            catch {
+                // 没有 go.mod
+            }
+            // 从 Cargo.toml 获取
+            try {
+                const cargo = await fs.readFile(path.join(this.projectRoot, 'Cargo.toml'), 'utf-8');
+                const nameMatch = cargo.match(/name\s*=\s*["']([^"']+)["']/);
+                if (nameMatch) {
+                    return nameMatch[1];
+                }
+            }
+            catch {
+                // 没有 Cargo.toml
+            }
+            // 从 pubspec.yaml 获取
+            try {
+                const pubspec = await fs.readFile(path.join(this.projectRoot, 'pubspec.yaml'), 'utf-8');
+                const nameMatch = pubspec.match(/name:\s*([^\s]+)/);
+                if (nameMatch) {
+                    return nameMatch[1];
+                }
+            }
+            catch {
+                // 没有 pubspec.yaml
+            }
+            // 从 composer.json 获取
+            try {
+                const composer = JSON.parse(await fs.readFile(path.join(this.projectRoot, 'composer.json'), 'utf-8'));
+                return composer.name || path.basename(this.projectRoot);
+            }
+            catch {
+                // 没有 composer.json
+            }
+            return path.basename(this.projectRoot);
+        }
+        catch {
+            return path.basename(this.projectRoot);
+        }
+    }
+    /**
+     * 在配置的扫描目录中查找文件
+     */
+    async findFile(fileName) {
+        for (const scanDir of this.config.scanDirs) {
+            // 跳过排除目录
+            if (this.config.excludeDirs.includes(scanDir)) {
+                continue;
+            }
+            const filePath = path.join(this.projectRoot, scanDir, fileName);
+            try {
+                await fs.access(filePath);
+                return filePath;
+            }
+            catch {
+                // 文件不存在
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 检测构建工具
+     */
+    async detectBuildTools(projectType) {
+        const buildTools = [];
+        // 检测 npm/yarn/pnpm scripts
+        const packageJsonPath = await this.findFile('package.json');
+        if (packageJsonPath) {
+            try {
+                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                if (packageJson.scripts && Object.keys(packageJson.scripts).length > 0) {
+                    // 检测包管理器类型
+                    let packageManager = 'npm';
+                    try {
+                        await fs.access(path.join(this.projectRoot, 'yarn.lock'));
+                        packageManager = 'yarn';
+                    }
+                    catch {
+                        // 没有 yarn.lock
+                    }
+                    try {
+                        await fs.access(path.join(this.projectRoot, 'pnpm-lock.yaml'));
+                        packageManager = 'pnpm';
+                    }
+                    catch {
+                        // 没有 pnpm-lock.yaml
+                    }
+                    const relativePath = path.relative(this.projectRoot, packageJsonPath);
+                    buildTools.push({
+                        type: packageManager,
+                        commands: Object.keys(packageJson.scripts),
+                        configFile: relativePath || 'package.json',
+                        isDefault: true
+                    });
+                    // 检测 bundler
+                    const allDeps = {
+                        ...packageJson.dependencies,
+                        ...packageJson.devDependencies
+                    };
+                    if (allDeps['webpack']) {
+                        buildTools.push({
+                            type: 'webpack',
+                            commands: ['build', 'watch'],
+                            configFile: 'webpack.config.js'
+                        });
+                    }
+                    if (allDeps['vite']) {
+                        buildTools.push({
+                            type: 'vite',
+                            commands: ['dev', 'build', 'preview'],
+                            configFile: 'vite.config.ts'
+                        });
+                    }
+                    if (allDeps['esbuild']) {
+                        buildTools.push({
+                            type: 'esbuild',
+                            commands: ['build'],
+                            configFile: 'esbuild.config.js'
+                        });
+                    }
+                    if (allDeps['rollup']) {
+                        buildTools.push({
+                            type: 'rollup',
+                            commands: ['build'],
+                            configFile: 'rollup.config.js'
+                        });
+                    }
+                    if (allDeps['turbo']) {
+                        buildTools.push({
+                            type: 'turbo',
+                            commands: ['build', 'test', 'lint'],
+                            configFile: 'turbo.json'
+                        });
+                    }
+                }
+            }
+            catch {
+                // 无法读取 package.json
+            }
+        }
+        // 检测 Makefile
+        const makefilePath = await this.findFile('Makefile');
+        if (makefilePath) {
+            try {
+                const makefile = await fs.readFile(makefilePath, 'utf-8');
+                // 提取 targets
+                const targets = [];
+                const lines = makefile.split('\n');
+                for (const line of lines) {
+                    const targetMatch = line.match(/^([a-zA-Z_-][a-zA-Z0-9_-]*):/);
+                    if (targetMatch && !targetMatch[1].startsWith('.')) {
+                        targets.push(targetMatch[1]);
+                    }
+                }
+                if (targets.length > 0) {
+                    const relativePath = path.relative(this.projectRoot, makefilePath);
+                    buildTools.push({
+                        type: 'make',
+                        commands: targets,
+                        configFile: relativePath || 'Makefile',
+                        isDefault: buildTools.length === 0
+                    });
+                }
+            }
+            catch {
+                // 无法读取 Makefile
+            }
+        }
+        // 检测 Docker
+        const dockerfilePath = await this.findFile('Dockerfile');
+        if (dockerfilePath) {
+            const relativePath = path.relative(this.projectRoot, dockerfilePath);
+            buildTools.push({
+                type: 'docker',
+                commands: ['build', 'run'],
+                configFile: relativePath || 'Dockerfile'
+            });
+        }
+        const dockerComposePath = await this.findFile('docker-compose.yml') ||
+            await this.findFile('docker-compose.yaml');
+        if (dockerComposePath) {
+            const relativePath = path.relative(this.projectRoot, dockerComposePath);
+            buildTools.push({
+                type: 'docker',
+                commands: ['up', 'down', 'build'],
+                configFile: relativePath || 'docker-compose.yml'
+            });
+        }
+        // 检测 Gradle
+        try {
+            await fs.access(path.join(this.projectRoot, 'build.gradle'));
+            buildTools.push({
+                type: 'gradle',
+                commands: ['build', 'test', 'run'],
+                configFile: 'build.gradle',
+                isDefault: projectType === 'java' && buildTools.length === 0
+            });
+        }
+        catch {
+            // 没有 build.gradle
+        }
+        try {
+            await fs.access(path.join(this.projectRoot, 'build.gradle.kts'));
+            buildTools.push({
+                type: 'gradle',
+                commands: ['build', 'test', 'run'],
+                configFile: 'build.gradle.kts',
+                isDefault: (projectType === 'java' || projectType === 'kotlin') && buildTools.length === 0
+            });
+        }
+        catch {
+            // 没有 build.gradle.kts
+        }
+        // 检测 Maven
+        try {
+            await fs.access(path.join(this.projectRoot, 'pom.xml'));
+            buildTools.push({
+                type: 'maven',
+                commands: ['compile', 'test', 'package', 'install', 'deploy'],
+                configFile: 'pom.xml',
+                isDefault: projectType === 'java' && !buildTools.some(t => t.type === 'gradle')
+            });
+        }
+        catch {
+            // 没有 pom.xml
+        }
+        // 检测 Cargo (Rust)
+        if (projectType === 'rust') {
+            try {
+                await fs.access(path.join(this.projectRoot, 'Cargo.toml'));
+                buildTools.push({
+                    type: 'cargo',
+                    commands: ['build', 'test', 'run', 'release'],
+                    configFile: 'Cargo.toml',
+                    isDefault: true
+                });
+            }
+            catch {
+                // 没有 Cargo.toml
+            }
+        }
+        // 检测 Go 命令
+        if (projectType === 'go') {
+            buildTools.push({
+                type: 'go',
+                commands: ['build', 'test', 'run', 'mod'],
+                configFile: 'go.mod',
+                isDefault: true
+            });
+        }
+        // 检测 pip (Python)
+        if (projectType === 'python') {
+            try {
+                await fs.access(path.join(this.projectRoot, 'requirements.txt'));
+                buildTools.push({
+                    type: 'pip',
+                    commands: ['install', 'freeze'],
+                    configFile: 'requirements.txt',
+                    isDefault: true
+                });
+            }
+            catch {
+                // 没有 requirements.txt
+            }
+            try {
+                await fs.access(path.join(this.projectRoot, 'pyproject.toml'));
+                // 检测是否使用 poetry
+                try {
+                    const pyproject = await fs.readFile(path.join(this.projectRoot, 'pyproject.toml'), 'utf-8');
+                    if (pyproject.includes('[tool.poetry]')) {
+                        buildTools.push({
+                            type: 'poetry',
+                            commands: ['install', 'build', 'publish'],
+                            configFile: 'pyproject.toml',
+                            isDefault: true
+                        });
+                    }
+                }
+                catch {
+                    // 无法读取 pyproject.toml
+                }
+            }
+            catch {
+                // 没有 pyproject.toml
+            }
+        }
+        // 检测 Bazel
+        try {
+            await fs.access(path.join(this.projectRoot, 'WORKSPACE'));
+            buildTools.push({
+                type: 'bazel',
+                commands: ['build', 'test', 'run'],
+                configFile: 'WORKSPACE'
+            });
+        }
+        catch {
+            // 没有 WORKSPACE
+        }
+        // 检测 NuGet/MSBuild (C#)
+        if (projectType === 'csharp') {
+            try {
+                const files = await fs.readdir(this.projectRoot);
+                const csprojFiles = files.filter(f => f.endsWith('.csproj'));
+                if (csprojFiles.length > 0) {
+                    buildTools.push({
+                        type: 'msbuild',
+                        commands: ['build', 'test', 'publish'],
+                        configFile: csprojFiles[0],
+                        isDefault: true
+                    });
+                }
+            }
+            catch {
+                // 无法读取目录
+            }
+        }
+        return buildTools;
+    }
+    /**
+     * 检测 CI 配置
+     */
+    async detectCIConfig() {
+        // GitHub Actions
+        try {
+            const workflowsDir = path.join(this.projectRoot, '.github', 'workflows');
+            const files = await fs.readdir(workflowsDir);
+            const workflowFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+            if (workflowFiles.length > 0) {
+                const configFiles = workflowFiles.map(f => `.github/workflows/${f}`);
+                const workflows = [];
+                for (const file of workflowFiles) {
+                    try {
+                        const content = await fs.readFile(path.join(workflowsDir, file), 'utf-8');
+                        const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
+                        if (nameMatch) {
+                            workflows.push(nameMatch[1].trim());
+                        }
+                    }
+                    catch {
+                        // 无法读取 workflow 文件
+                    }
+                }
+                return {
+                    platform: 'github-actions',
+                    configFiles,
+                    workflows
+                };
+            }
+        }
+        catch {
+            // 没有 GitHub Actions
+        }
+        // GitLab CI
+        try {
+            await fs.access(path.join(this.projectRoot, '.gitlab-ci.yml'));
+            return {
+                platform: 'gitlab-ci',
+                configFiles: ['.gitlab-ci.yml']
+            };
+        }
+        catch {
+            // 没有 GitLab CI
+        }
+        // Jenkins
+        try {
+            await fs.access(path.join(this.projectRoot, 'Jenkinsfile'));
+            return {
+                platform: 'jenkins',
+                configFiles: ['Jenkinsfile']
+            };
+        }
+        catch {
+            // 没有 Jenkins
+        }
+        // CircleCI
+        try {
+            await fs.access(path.join(this.projectRoot, '.circleci', 'config.yml'));
+            return {
+                platform: 'circleci',
+                configFiles: ['.circleci/config.yml']
+            };
+        }
+        catch {
+            // 没有 CircleCI
+        }
+        // Travis CI
+        try {
+            await fs.access(path.join(this.projectRoot, '.travis.yml'));
+            return {
+                platform: 'travis-ci',
+                configFiles: ['.travis.yml']
+            };
+        }
+        catch {
+            // 没有 Travis CI
+        }
+        // Azure Pipelines
+        try {
+            await fs.access(path.join(this.projectRoot, 'azure-pipelines.yml'));
+            return {
+                platform: 'azure-pipelines',
+                configFiles: ['azure-pipelines.yml']
+            };
+        }
+        catch {
+            // 没有 Azure Pipelines
+        }
+        // Bitbucket Pipelines
+        try {
+            await fs.access(path.join(this.projectRoot, 'bitbucket-pipelines.yml'));
+            return {
+                platform: 'bitbucket-pipelines',
+                configFiles: ['bitbucket-pipelines.yml']
+            };
+        }
+        catch {
+            // 没有 Bitbucket Pipelines
+        }
+        return undefined;
+    }
+    /**
+     * 检测部署选项
+     */
+    async detectDeployOptions(buildTools) {
+        const deployOptions = [];
+        // Docker 部署
+        const dockerTool = buildTools.find(t => t.type === 'docker');
+        if (dockerTool?.configFile === 'Dockerfile') {
+            deployOptions.push({
+                method: 'docker',
+                command: 'docker build -t <image-name> . && docker run <image-name>',
+                configFile: 'Dockerfile',
+                recommended: true,
+                description: '使用 Docker 容器部署'
+            });
+        }
+        if (dockerTool?.configFile === 'docker-compose.yml' || dockerTool?.configFile === 'docker-compose.yaml') {
+            deployOptions.push({
+                method: 'docker-compose',
+                command: 'docker-compose up -d',
+                configFile: dockerTool.configFile,
+                recommended: deployOptions.length === 0,
+                description: '使用 Docker Compose 多容器部署'
+            });
+        }
+        // Kubernetes 部署
+        try {
+            const k8sDir = path.join(this.projectRoot, 'k8s');
+            const files = await fs.readdir(k8sDir);
+            const yamlFiles = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+            if (yamlFiles.length > 0) {
+                deployOptions.push({
+                    method: 'kubernetes',
+                    command: 'kubectl apply -f k8s/',
+                    configFile: `k8s/${yamlFiles.join(', ')}`,
+                    description: '使用 Kubernetes 部署'
+                });
+            }
+        }
+        catch {
+            // 没有 k8s 目录
+        }
+        // Helm 部署
+        try {
+            const helmDir = path.join(this.projectRoot, 'helm');
+            const files = await fs.readdir(helmDir);
+            if (files.some(f => f === 'Chart.yaml' || f.endsWith('.yaml'))) {
+                deployOptions.push({
+                    method: 'helm',
+                    command: 'helm install <release-name> helm/',
+                    configFile: 'helm/Chart.yaml',
+                    description: '使用 Helm Chart 部署到 Kubernetes'
+                });
+            }
+        }
+        catch {
+            // 没有 helm 目录
+        }
+        // Makefile 部署命令
+        const makeTool = buildTools.find(t => t.type === 'make');
+        if (makeTool) {
+            const deployTargets = makeTool.commands.filter(cmd => cmd.includes('deploy') || cmd.includes('publish') || cmd.includes('release'));
+            for (const target of deployTargets) {
+                deployOptions.push({
+                    method: 'make',
+                    command: `make ${target}`,
+                    configFile: 'Makefile',
+                    description: `使用 Makefile ${target} 命令部署`
+                });
+            }
+        }
+        // npm 部署脚本
+        const npmTool = buildTools.find(t => t.type === 'npm' || t.type === 'yarn' || t.type === 'pnpm');
+        if (npmTool) {
+            const deployScripts = npmTool.commands.filter(cmd => cmd.includes('deploy') || cmd.includes('publish'));
+            for (const script of deployScripts) {
+                const pmCommand = npmTool.type === 'yarn' ? 'yarn' :
+                    npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run';
+                deployOptions.push({
+                    method: 'npm',
+                    command: `${pmCommand} ${script}`,
+                    configFile: 'package.json',
+                    description: `使用 npm script ${script} 部署`
+                });
+            }
+        }
+        // GitHub Pages
+        try {
+            const packageJsonPath = path.join(this.projectRoot, 'package.json');
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            if (packageJson.homepage?.includes('github.io') ||
+                packageJson.scripts?.deploy?.includes('gh-pages')) {
+                deployOptions.push({
+                    method: 'github-pages',
+                    command: 'npm run deploy',
+                    configFile: 'package.json',
+                    description: '部署到 GitHub Pages'
+                });
+            }
+        }
+        catch {
+            // 没有 package.json 或不是 GitHub Pages 项目
+        }
+        // Vercel
+        try {
+            await fs.access(path.join(this.projectRoot, 'vercel.json'));
+            deployOptions.push({
+                method: 'vercel',
+                command: 'vercel deploy',
+                configFile: 'vercel.json',
+                recommended: true,
+                description: '部署到 Vercel 平台'
+            });
+        }
+        catch {
+            // 没有 vercel.json
+        }
+        // Netlify
+        try {
+            await fs.access(path.join(this.projectRoot, 'netlify.toml'));
+            deployOptions.push({
+                method: 'netlify',
+                command: 'netlify deploy',
+                configFile: 'netlify.toml',
+                recommended: true,
+                description: '部署到 Netlify 平台'
+            });
+        }
+        catch {
+            // 没有 netlify.toml
+        }
+        return deployOptions;
+    }
+    /**
+     * 获取开发命令
+     */
+    async getDevCommands(projectType, buildTools) {
+        const commands = {
+            setup: [],
+            build: [],
+            test: [],
+            dev: [],
+            start: []
+        };
+        // 检测包管理器
+        const npmTool = buildTools.find(t => t.type === 'npm' || t.type === 'yarn' || t.type === 'pnpm');
+        const pmCommand = npmTool?.type === 'yarn' ? 'yarn' :
+            npmTool?.type === 'pnpm' ? 'pnpm' : 'npm';
+        // 根据项目类型设置默认命令
+        if (npmTool) {
+            commands.setup.push(`${pmCommand} install`);
+            // 从 scripts 中提取命令
+            const scriptCommands = npmTool.commands;
+            if (scriptCommands.includes('build')) {
+                commands.build.push(`${npmTool.type === 'yarn' ? 'yarn' : npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run'} build`);
+            }
+            if (scriptCommands.includes('test')) {
+                commands.test.push(`${npmTool.type === 'yarn' ? 'yarn' : npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run'} test`);
+            }
+            if (scriptCommands.includes('dev')) {
+                commands.dev.push(`${npmTool.type === 'yarn' ? 'yarn' : npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run'} dev`);
+            }
+            if (scriptCommands.includes('start')) {
+                commands.start.push(`${npmTool.type === 'yarn' ? 'yarn' : npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run'} start`);
+            }
+            if (scriptCommands.includes('lint')) {
+                commands.lint = [`${npmTool.type === 'yarn' ? 'yarn' : npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run'} lint`];
+            }
+            if (scriptCommands.includes('format') || scriptCommands.includes('fmt')) {
+                commands.format = [`${npmTool.type === 'yarn' ? 'yarn' : npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run'} ${scriptCommands.includes('format') ? 'format' : 'fmt'}`];
+            }
+            if (scriptCommands.includes('clean')) {
+                commands.clean = [`${npmTool.type === 'yarn' ? 'yarn' : npmTool.type === 'pnpm' ? 'pnpm run' : 'npm run'} clean`];
+            }
+        }
+        // Makefile 命令
+        const makeTool = buildTools.find(t => t.type === 'make');
+        if (makeTool) {
+            for (const target of makeTool.commands) {
+                if (target === 'build' || target === 'compile') {
+                    commands.build.push(`make ${target}`);
+                }
+                if (target === 'test' || target === 'check') {
+                    commands.test.push(`make ${target}`);
+                }
+                if (target === 'dev' || target === 'develop' || target === 'watch') {
+                    commands.dev.push(`make ${target}`);
+                }
+                if (target === 'start' || target === 'run') {
+                    commands.start.push(`make ${target}`);
+                }
+                if (target === 'clean') {
+                    commands.clean = [`make clean`];
+                }
+            }
+        }
+        // Python 项目命令
+        if (projectType === 'python') {
+            commands.setup.push('pip install -r requirements.txt');
+            // 检测是否有 tests 目录
+            try {
+                await fs.access(path.join(this.projectRoot, 'tests'));
+                commands.test.push('pytest tests/');
+            }
+            catch {
+                // 没有 tests 目录
+            }
+            try {
+                await fs.access(path.join(this.projectRoot, 'test'));
+                commands.test.push('pytest test/');
+            }
+            catch {
+                // 没有 test 目录
+            }
+            // 检测 Poetry
+            try {
+                const pyproject = await fs.readFile(path.join(this.projectRoot, 'pyproject.toml'), 'utf-8');
+                if (pyproject.includes('[tool.poetry]')) {
+                    commands.setup.push('poetry install');
+                    commands.build.push('poetry build');
+                }
+            }
+            catch {
+                // 没有 pyproject.toml
+            }
+        }
+        // Go 项目命令
+        if (projectType === 'go') {
+            commands.setup.push('go mod download');
+            commands.build.push('go build');
+            commands.test.push('go test ./...');
+            commands.start.push('go run main.go');
+        }
+        // Rust 项目命令
+        if (projectType === 'rust') {
+            commands.setup.push('cargo fetch');
+            commands.build.push('cargo build');
+            commands.test.push('cargo test');
+            commands.start.push('cargo run');
+            commands.clean = ['cargo clean'];
+        }
+        // Java/Maven 项目命令
+        if (projectType === 'java') {
+            const mavenTool = buildTools.find(t => t.type === 'maven');
+            if (mavenTool) {
+                commands.setup.push('mvn dependency:resolve');
+                commands.build.push('mvn compile');
+                commands.test.push('mvn test');
+                commands.start.push('mvn exec:java');
+                commands.clean = ['mvn clean'];
+            }
+            const gradleTool = buildTools.find(t => t.type === 'gradle');
+            if (gradleTool) {
+                commands.setup.push('gradle dependencies');
+                commands.build.push('gradle build');
+                commands.test.push('gradle test');
+                commands.start.push('gradle run');
+                commands.clean = ['gradle clean'];
+            }
+        }
+        // C# 项目命令
+        if (projectType === 'csharp') {
+            commands.setup.push('dotnet restore');
+            commands.build.push('dotnet build');
+            commands.test.push('dotnet test');
+            commands.start.push('dotnet run');
+            commands.clean = ['dotnet clean'];
+        }
+        // Docker 命令
+        const dockerTool = buildTools.find(t => t.type === 'docker');
+        if (dockerTool) {
+            if (dockerTool.configFile === 'docker-compose.yml' || dockerTool.configFile === 'docker-compose.yaml') {
+                commands.start.push('docker-compose up');
+                commands.clean = commands.clean || [];
+                commands.clean.push('docker-compose down');
+            }
+        }
+        return commands;
+    }
+    /**
+     * 转换为 JSON 字符串
+     */
+    toJSON(result) {
+        return JSON.stringify(result, null, 2);
+    }
+}
+exports.EnvironmentDetector = EnvironmentDetector;