@chongyan/autospec 1.0.2 → 1.0.4

package/plugins/commands/env-sync.md

@@ -1,1281 +0,0 @@
----
-description: 初始化环境目录并同步环境知识，AI 提炼最佳实践和配置模板
----
-
-# AutoSpec Env Sync — 环境知识同步
-
-## 用户输入
-
-```
-$ARGUMENTS
-```
-
----
-
-## 执行指令
-
-### Step 0: 初始化目录结构
-
-**【强制】** 创建精简的目录结构，与 `knowledge/09-templates/` 模板一一对应：
-
-```
-.autospec/environment/
-├── 01-env-knowledge/              # 环境知识
-│   ├── middleware/                # 中间件知识（含外部服务）→ 10-middleware-knowledge.md
-│   ├── infrastructure/            # 基础设施知识
-│   └── env-variables/             # 环境变量
-│
-├── 02-component-lib/              # 组件库
-│   ├── components/                # 组织组件 → 08-component-knowledge.md
-│   └── best-practices/            # 最佳实践 → 09-best-practices.md
-│
-├── 03-design-knowledge/           # 设计知识
-│   ├── product/                   # 产品设计 → 00-requirement-proposal.md, 04-product-design.md
-│   ├── architecture/              # 架构设计 → 01-architecture-design.md
-│   ├── api/                       # API 设计（含 RPC）→ 02-api-design.md
-│   └── database/                  # 数据库设计 → 03-database-design.md
-│
-├── 04-business-knowledge/         # 业务知识
-│   └── {domain-name}.md           # 领域业务知识（含数据模型）→ 05-domain-business.md
-│
-├── 05-test-knowledge/             # 测试知识
-│   ├── test-designs/              # 测试设计 → 06-test-design.md
-│   └── evaluation/                # 评测设计 → 07-evaluation-design.md
-│
-├── 06-standards/                  # 规范文档
-├── 07-guides/                     # 指南
-├── 08-integration/                # 集成配置
-├── registry.json                  # 知识注册表
-└── knowledge-source.json          # 知识来源配置
-```
-
-**设计原则**：
-- **高内聚低耦合**：相关内容聚合，避免过度拆分
-- **模板对应**：目录与 `knowledge/09-templates/` 一一对应
-- **整合优化**：RPC 服务合并到 api/，数据模型合并到 business-knowledge/
-
-**初始化 registry.json**（如不存在）：
-
-```json
-{
-  "version": "2.1",
-  "activeProfiles": {
-    "environment": "development",
-    "components": []
-  },
-  "environmentKnowledge": {
-    "middleware": [],
-    "infrastructure": [],
-    "envVariables": []
-  },
-  "componentKnowledge": {
-    "components": [],
-    "bestPractices": []
-  },
-  "designKnowledge": {
-    "product": [],
-    "architecture": [],
-    "api": [],
-    "database": []
-  },
-  "businessKnowledge": [],
-  "testKnowledge": {
-    "testDesigns": [],
-    "evaluation": []
-  },
-  "standardsKnowledge": [],
-  "guidesKnowledge": [],
-  "integrationKnowledge": []
-}
-```
-
-### Step 0.5: 加载模板和检测规则
-
-**【强制】** 读取模板文件和检测规则：
-
-1. **读取检测规则**
-   - `knowledge/06-environment/01-detection-patterns.yaml`
-   - 解析 buildFiles, frameworks, designDocs, businessDocs, testDocs, sourceAnalysis 规则
-
-2. **读取模板文件**
-   - 中间件模板：`knowledge/09-templates/10-middleware-knowledge.md`
-   - 组件模板：`knowledge/09-templates/08-component-knowledge.md`
-   - 设计模板：`knowledge/09-templates/01-architecture-design.md`, `02-api-design.md`, `03-database-design.md`, `00-requirement-proposal.md`
-   - 测试模板：`knowledge/09-templates/06-test-design.md`, `07-evaluation-design.md`
-   - 业务模板：`knowledge/09-templates/05-domain-business.md`
-   - 最佳实践模板：`knowledge/09-templates/09-best-practices.md`
-
-3. **缓存模板信息**
-   - 必填章节列表
-   - 类型枚举
-   - 输出路径模板
-
----
-
-## Step 1: 扫描代码和依赖（多语言支持）
-
-**【强制】** 根据 `detection-patterns.yaml` 执行多语言扫描：
-
-### 1.0 多项目检测（规则 + 模型驱动）
-
-**【强制】** 首先检测工作目录下的所有子项目：
-
-**规则检测**：
-```bash
-# 检测所有构建文件
-find . -maxdepth 3 \( -name "pom.xml" -o -name "package.json" -o -name "go.mod" -o -name "Cargo.toml" -o -name "pyproject.toml" \) -not -path "*/node_modules/*" -not -path "*/target/*"
-```
-
-**模型驱动检测**（使用 `modelDrivenDetection.stages.projectDiscovery`）：
-
-当规则检测完成后，启用模型探索模式：
-
-```
-你是一个项目结构分析专家。请探索当前工作目录，发现所有子项目。
-
-## 探索工具
-
-使用以下工具进行探索：
-- find: 查找构建文件和目录结构
-- grep: 搜索特定内容
-- read: 读取配置文件
-
-## 探索目标
-
-1. 发现非标准目录结构的项目（如 app/, modules/, services/）
-2. 识别多模块项目的父子关系
-3. 发现隐藏的项目配置
-4. 分析项目间的依赖关系
-
-## 输出
-
-生成项目列表，包含：name, path, language, framework, type, buildTool, srcDirs, entryPoint
-```
-
-**输出**：
-```json
-{
-  "projects": [
-    {
-      "name": "project-a",
-      "path": "project-a",
-      "language": "java",
-      "framework": "Spring Boot",
-      "type": "backend",
-      "buildTool": "maven",
-      "srcDirs": ["src/main/java"],
-      "entryPoint": "src/main/java/.../Application.java"
-    },
-    {
-      "name": "project-b",
-      "path": "project-b",
-      "language": "java",
-      "framework": "Spring Boot",
-      "type": "hybrid",
-      "types": ["backend", "ai-assistant"],
-      "buildTool": "maven",
-      "srcDirs": ["app/*/src/main/java"]
-    }
-  ]
-}
-```
-
-### 1.1 识别项目语言
-
-扫描构建文件确定项目类型：
-
-| 构建文件 | 语言 | 解析器 |
-|---------|------|--------|
-| package.json | JavaScript/TypeScript | packageJson |
-| pom.xml | Java (Maven) | pomXml |
-| build.gradle | Java/Kotlin (Gradle) | buildGradle |
-| build.gradle.kts | Kotlin (Gradle) | buildGradleKts |
-| go.mod | Go | goMod |
-| Cargo.toml | Rust | cargoToml |
-| pyproject.toml | Python (Poetry/PDM) | pyprojectToml |
-| requirements.txt | Python (pip) | requirements |
-| setup.py | Python (setuptools) | setupPy |
-| dbt_project.yml | SQL (dbt) | dbtProject |
-| pubspec.yaml | Dart/Flutter | pubspec |
-| composer.json | PHP | composer |
-| Gemfile | Ruby | gemfile |
-
-**支持多模块项目路径**：
-- `src/main/java` - 标准路径
-- `app/*/src/main/java` - 多模块路径
-- `*/src/main/java` - 通用多模块路径
-
-### 1.2 提取依赖和框架
-
-**提取依赖列表**：
-- 读取对应的构建文件
-- 解析依赖声明
-
-**匹配框架规则**（使用 frameworks 规则）：
-- JavaScript: react, vue, angular, express, nestjs, next, nuxt 等
-- Python: django, fastapi, flask, torch, tensorflow, langchain, crewai 等
-- Java: spring-boot, spring-cloud, dubbo, quarkus 等
-- Go: gin, echo, fiber, chi 等
-- Rust: actix, rocket, warp, axum 等
-
-**识别 AI/数据组件**（使用 aiComponents 和 dataComponents 规则）：
-- LLM 应用：langchain, llamaindex, openai, anthropic
-- Agent 框架：crewai, autogen, semantic-kernel
-- 向量存储：faiss, chromadb, pinecone, weaviate
-- 模型训练：torch, tensorflow, transformers
-- 数据仓库：dbt
-- ETL 管道：airflow, prefect, dagster
-
-### 1.3 模型驱动中间件检测
-
-**【强制】** 使用 `modelDrivenDetection.stages.middlewareDiscovery` 进行深度检测：
-
-```
-你是一个中间件和框架识别专家。请深入分析项目，发现所有使用的中间件和框架。
-
-## 探索工具
-
-使用以下工具进行探索：
-- grep: 搜索依赖声明、配置项、import 语句
-- read: 读取构建文件和配置文件
-
-## 探索步骤
-
-1. 分析依赖：grep 构建文件中的依赖声明
-2. 扫描配置：查找 application*.properties/yml 中的配置项
-3. 扫描代码：grep import 语句识别引入的库
-4. 识别客户端：grep Client/Config/Manager 类
-
-## 识别标准
-
-- 数据库: DataSource, Connection, Repository, Mapper, DAO
-- 缓存: Cache, Redis, Memcached, CacheManager
-- 消息队列: Producer, Consumer, Queue, Topic, Message
-- RPC: RpcClient, RpcServer, Facade, Stub
-- 存储: OssClient, S3Client, StorageService
-- LLM: LLMClient, ChatService, Embedding, VectorStore
-```
-
-**输出**：
-```json
-{
-  "middleware": [
-    {
-      "name": "distributed-db",
-      "type": "database",
-      "detectionSource": "config",
-      "configKeys": ["datasource.name", "datasource.version"],
-      "clientClasses": ["DataSourceConfig"],
-      "version": "1.0.0",
-      "confidence": 0.95
-    }
-  ],
-  "externalServices": [
-    {
-      "name": "llm-service",
-      "type": "llm",
-      "endpoint": "llm.service.url",
-      "clientClass": "LLMClient",
-      "confidence": 0.92
-    }
-  ]
-}
-```
-
-### 1.3.1 RPC 服务检测（新增）
-
-**【强制】** 使用 `rpcServices` 规则检测 RPC 服务：
-
-**服务提供者检测**：
-```bash
-# 检测 @RpcProvider 注解
-grep -rn "@RpcProvider\|@DubboService\|@GrpcService" --include="*.java"
-
-# 提取服务实现类
-grep -rn "implements.*Facade\|implements.*Service" --include="*.java"
-```
-
-**Facade 接口检测**：
-```bash
-# 检测 Facade 接口定义
-grep -rn "interface.*Facade\|interface.*Service" --include="*.java"
-
-# 扫描 facade 模块目录
-find . -path "*/app/facade/*" -name "*.java"
-find . -path "*/api/src/main/java/*" -name "*.java"
-```
-
-**服务引用检测**：
-```bash
-# 检测 RPC 服务引用
-grep -rn "@RpcReference\|@DubboReference\|@FeignClient" --include="*.java"
-```
-
-**输出**：
-```json
-{
-  "rpcServices": [
-    {
-      "interface": "AssistantChatFacade",
-      "implementation": "AssistantChatFacadeImpl",
-      "methods": ["chat", "streamChat"],
-      "sourceFile": "app/facade/src/main/java/.../AssistantChatFacade.java",
-      "references": [
-        {"project": "backend", "file": "ChatController.java"}
-      ]
-    }
-  ]
-}
-```
-
-### 1.3.2 外部服务客户端检测（新增）
-
-**【强制】** 使用 `externalServiceClients` 规则检测外部服务：
-
-**客户端类检测**：
-```bash
-# 检测客户端类
-grep -rn "class.*Client\|class.*FacadeClient\|class.*Adapter\|class.*Gateway" --include="*.java" -l
-
-# 提取客户端方法
-grep -rn "public.*call\|public.*invoke\|public.*request\|public.*query" --include="*Client.java"
-```
-
-**配置项提取**：
-```bash
-# 提取服务端点配置
-grep -rn "\.service-url\|\.endpoint\|\.tr-service-url" --include="*.properties" --include="*.yml"
-
-# 提取超时和重试配置
-grep -rn "\.timeout\|\.retry\|\.retries" --include="*.properties" --include="*.yml"
-```
-
-**服务类型分类**：
-- LLM 服务：LLMClient, ChatClient, ModelClient
-- 向量服务：VectorClient, EmbeddingClient
-- 存储服务：OssClient, StorageClient
-- 消息服务：MqClient, MessageClient
-- 认证服务：AuthClient, SecurityClient
-
-**输出**：
-```json
-{
-  "externalServiceClients": [
-    {
-      "name": "LLMServiceClient",
-      "type": "llm",
-      "endpoint": "llm.service.url",
-      "methods": ["chat", "embed"],
-      "configKeys": ["llm.service.url", "llm.timeout"],
-      "sourceFile": "app/client/src/main/java/.../LLMServiceClient.java"
-    }
-  ]
-}
-```
-
-### 1.3.3 数据模型检测（新增）
-
-**【强制】** 使用 `dataModels` 规则检测数据模型：
-
-**DO/Entity 类检测**：
-```bash
-# 检测 DO 类
-grep -rn "class.*DO\|class.*Entity\|class.*PO\|class.*DTO" --include="*.java" -l
-
-# 检测 @Entity @Table 注解
-grep -rn "@Entity\|@Table\|@TableName" --include="*.java" -l
-```
-
-**表映射检测**：
-```bash
-# 提取表名
-grep -rn "@Table(name\|@TableName(" --include="*.java"
-
-# 提取字段映射
-grep -rn "@Column\|@Field" --include="*.java"
-```
-
-**大数据存储模型检测**：
-```bash
-# 检测大数据存储目录
-find . -path "*/app/dal/**/bigdata/*" -name "*.java"
-find . -path "*/app/dal/**/lindorm/*" -name "*.java"
-find . -path "*/app/dal/**/hbase/*" -name "*.java"
-
-# 检测 TDO 类
-grep -rn "class.*TDO" --include="*.java" -l
-```
-
-**输出**：
-```json
-{
-  "dataModels": [
-    {
-      "name": "SessionDO",
-      "type": "DO",
-      "table": "t_session",
-      "fields": [
-        {"name": "id", "type": "Long", "column": "id", "primaryKey": true},
-        {"name": "userId", "type": "String", "column": "user_id"}
-      ],
-      "sourceFile": "app/dal/src/main/java/.../SessionDO.java"
-    }
-  ]
-}
-```
-
-### 1.3.4 消息消费者检测（新增）
-
-**【强制】** 使用 `messageConsumers` 规则检测消息消费者：
-
-**消费者检测**：
-```bash
-# 检测消息消费者注解
-grep -rn "@MessageConsumer\|@KafkaListener\|@RabbitListener\|@RocketMQMessageListener" --include="*.java"
-
-# 提取 Topic 配置
-grep -rn "topic\s*=\|queues\s*=" --include="*.java"
-```
-
-**生产者检测**：
-```bash
-# 检测生产者类
-grep -rn "class.*Producer\|class.*Publisher" --include="*.java" -l
-```
-
-**输出**：
-```json
-{
-  "messageConsumers": [
-    {
-      "class": "ChatEventConsumer",
-      "topic": "TP_CHAT_EVENT",
-      "method": "onMessage",
-      "sourceFile": "app/consumer/src/main/java/.../ChatEventConsumer.java"
-    }
-  ]
-}
-```
-
-### 1.4 扫描环境变量模式
-
-使用 grep 扫描多语言环境变量：
-
-```bash
-# JavaScript/TypeScript
-grep -r "process\.env\." --include="*.js" --include="*.ts"
-
-# Python
-grep -r "os\.environ" --include="*.py"
-grep -r "getenv(" --include="*.py"
-
-# Java
-grep -r "System\.getenv" --include="*.java"
-grep -r "@Value" --include="*.java"
-
-# Go
-grep -r "os\.Getenv" --include="*.go"
-
-# Rust
-grep -r "std::env::" --include="*.rs"
-```
-
-### 1.5 输出扫描结果
-
-生成 `.autospec/runtime/env-scan-result.json`：
-
-```json
-{
-  "projects": [
-    {"name": "project-a", "path": "project-a", "language": "java", "framework": "Spring Boot"}
-  ],
-  "language": "java",
-  "buildTool": "maven",
-  "frameworks": ["Spring Boot", "Dubbo"],
-  "middleware": [
-    {"name": "distributed-db", "type": "database", "confidence": 0.95}
-  ],
-  "externalServices": [
-    {"name": "llm-service", "type": "llm", "confidence": 0.92}
-  ],
-  "aiComponents": [],
-  "dataComponents": ["dbt"],
-  "envVariables": ["DB_HOST", "REDIS_ENDPOINT"],
-  "sourceDirectories": {
-    "backend": ["backend/src/main/java"],
-    "data": ["data/warehouse"]
-  },
-  "projectDependencies": [
-    {"from": "project-a", "to": "project-b", "type": "rpc", "services": ["XxxFacade"]}
-  ]
-}
-```
-
-### 1.6 置信度过滤
-
-**【强制】** 对检测结果按置信度分级处理：
-
-| 置信度范围 | 级别 | 处理方式 |
-|-----------|------|---------|
-| ≥ 0.85 | 高 | 直接采用，自动生成知识文件 |
-| 0.65 - 0.85 | 中 | 标记「待确认」，生成文件但添加 review 标记 |
-| 0.45 - 0.65 | 低 | 仅记录到扫描结果，不生成知识文件 |
-| < 0.45 | 忽略 | 不记录 |
-
-**输出格式**：
-
-```json
-{
-  "high": [...],      // 直接采用
-  "medium": [...],    // 待确认
-  "low": [...],       // 仅记录
-  "ignored": [...]    // 忽略
-}
-```
-
-**待确认文件标记**：
-
-在生成的 `.md` 文件头部添加：
-
-```markdown
-> ⚠️ **待确认**: 此文件由模型检测生成（置信度: 0.72），请人工确认后移除此标记。
-```
-
----
-
-## Step 2: 扫描项目文档（设计/测试/业务）
-
-**【强制】** 按优先级扫描三类文档：
-
-### 2.1 扫描设计文档（使用 designDocs 规则）
-
-**产品设计**：
-- 扫描位置：`specs/proposal.md`, `docs/product/`, `product/`, `docs/requirements/`, `knowledge/02-process/`
-- 文件模式：`*proposal*.md`, `*product*.md`, `*requirement*.md`
-- 输出目录：`03-design-knowledge/01-product/`
-
-**架构设计**：
-- 扫描位置：`specs/design.md`, `docs/architecture/`, `architecture/`, `docs/design/`, `knowledge/03-guides/`
-- 文件模式：`*design*.md`, `*architecture*.md`, `*.uml`, `*.plantuml`, `*.md`
-- 输出目录：`03-design-knowledge/02-architecture/`
-
-**接口设计**：
-- 扫描位置：`docs/api/`, `openapi/`, `api/`, `specs/contracts/`, `app/facade/`, `app/web/`
-- 文件模式：`openapi.yaml`, `openapi.json`, `swagger.yaml`, `swagger.json`, `*api*.md`
-- 输出目录：`03-design-knowledge/03-api/`
-
-**数据库设计**：
-- 扫描位置：`docs/database/`, `db/`, `schema/`, `migrations/`, `app/dal/`, `app/model/`
-- 文件模式：`*schema*.sql`, `*database*.md`, `*.sql`, `*.ddl`, `*.proto`
-- 输出目录：`03-design-knowledge/04-database/`
-
-### 2.2 扫描测试文档（使用 testDocs 规则）
-
-**测试设计**：
-- 扫描位置：`specs/testcase.md`, `tests/design/`, `test/`, `specs/`
-- 文件模式：`*testcase*.md`, `*test-design*.md`
-- 输出目录：`05-test-knowledge/01-test-designs/`
-
-**评测设计**：
-- 扫描位置：`evaluation/`, `eval/`, `benchmarks/`, `tests/evaluation/`
-- 文件模式：`*eval*.md`, `*benchmark*.md`, `*metrics*.md`
-- 输出目录：`05-test-knowledge/02-evaluation/`
-
-### 2.3 扫描业务知识（使用 domain-business 模板）
-
-**领域业务知识**：
-- 扫描位置：`docs/business/`, `knowledge/`, `docs/domain/`, `business/`
-- 文件模式：`*glossary*.md`, `*terminology*.md`, `*rules*.md`, `*policy*.md`, `*flow*.md`, `*process*.md`, `*domain*.md`
-- 输出目录：`04-business-knowledge/{domain-name}.md`
-- 使用模板：`knowledge/09-templates/05-domain-business.md`
-
-**整合内容**：
-- 业务术语表（统一语言）
-- 业务规则
-- 业务流程
-- 领域模型（含数据模型）
-- 实体详情
-
-### 2.4 扫描规范指南
-
-**规范文档**：
-- 扫描位置：`docs/standards/`, `.editorconfig`, `checkstyle.xml`
-- 输出目录：`06-standards/`
-
-**指南文档**：
-- 扫描位置：`docs/guides/`, `knowledge/03-guides/`
-- 输出目录：`07-guides/`
-
-### 2.5 模型兜底扫描（Fallback）
-
-**【强制】** 当规则匹配完成后，执行模型兜底扫描，捕获规则之外的潜在文档：
-
-#### 2.5.1 收集未匹配文件
-
-```bash
-# 收集所有未被规则匹配的 Markdown 文件
-find docs/ specs/ knowledge/ business/ tests/ -name "*.md" \
-  ! -path "*/node_modules/*" \
-  ! -path "*/.git/*" \
-  ! -path "*/.autospec/*" \
-  | sort > /tmp/unmatched-files.txt
-```
-
-#### 2.5.2 排除已匹配文件
-
-```bash
-# 从全部文件中减去已规则匹配的文件
-comm -23 /tmp/all-md-files.txt /tmp/matched-files.txt > /tmp/candidate-files.txt
-```
-
-#### 2.5.3 AI 模型分类
-
-**调用模型**，传入 `detection-patterns.yaml` 中定义的 `fallback.aiPrompt`：
-
-```
-输入：候选文件列表 + 文件内容摘要
-处理：使用对应的 aiPrompt 进行分类识别
-输出：JSON 格式的分类结果
-```
-
-**设计文档兜底**：
-- 使用 `designDocs.fallback.aiPrompt`
-- 识别架构/API/数据库/产品设计文档
-- 输出到对应子目录
-
-**业务文档兜底**：
-- 使用 `businessDocs.fallback.aiPrompt`
-- 识别术语表/业务规则/业务流程文档
-- 输出到对应子目录
-
-**测试文档兜底**：
-- 使用 `testDocs.fallback.aiPrompt`
-- 识别测试设计/评测设计文档
-- 输出到对应子目录
-
-#### 2.5.4 置信度过滤
-
-```yaml
-# 只保留置信度 >= 0.7 的分类结果
-confidenceThreshold: 0.7
-
-# 置信度 0.5-0.7 的标记为"待确认"
-reviewThreshold: 0.5
-
-# 置信度 < 0.5 的忽略
-ignoreThreshold: 0.5
-```
-
-#### 2.5.5 生成兜底报告
-
-```markdown
-## 模型兜底扫描结果
-
-### 设计文档
-- ✅ `docs/random-design.md` → architecture (confidence: 0.92)
-- ✅ `docs/api-intro.md` → api (confidence: 0.85)
-- ⚠️  `docs/overview.md` → product (confidence: 0.68, 待确认)
-
-### 业务文档
-- ✅ `docs/terms.md` → glossary (confidence: 0.88)
-- ✅ `docs/rules.md` → rules (confidence: 0.91)
-
-### 测试文档
-- ✅ `tests/manual-cases.md` → test-designs (confidence: 0.79)
-
-总计：发现 7 个规则外文档，6 个高置信度，1 个待确认
-```
-
----
-
-## Step 3: 分析项目结构（多语言源码分析）
-
-**【强制】** 使用 model+grep 方式分析源码结构：
-
-### 3.1 Java 项目分析
-
-```yaml
-# 使用 sourceAnalysis.java 规则
-buildFiles: [pom.xml, build.gradle]
-srcDirs:
-  - src/main/java
-  - src/main/kotlin
-  - "app/*/src/main/java"      # 多模块项目
-  - "*/src/main/java"          # 通用多模块
-
-# Grep 模式提取架构信息
-grepPatterns:
-  package: "^package\\s+([\\w.]+);"
-  import: "^import\\s+([\\w.]+);"
-  class: "public\\s+class\\s+(\\w+)"
-  interface: "public\\s+interface\\s+(\\w+)"
-  facade: "interface.*Facade"
-
-# 注解识别
-annotations:
-  restController: "@RestController"
-  service: "@Service"
-  repository: "@Repository"
-  entity: "@Entity"
-  controller: "@Controller"
-  rpcProvider: "@RpcProvider"
-  rpcReference: "@RpcReference"
-```
-
-**分析输出**：
-- 包结构列表
-- 核心类列表
-- Controller/Service/Repository 分布
-- RPC 服务分布（@RpcProvider）
-- 实体类列表
-
-### 3.2 Node.js 项目分析
-
-```yaml
-# 使用 sourceAnalysis.nodejs 规则
-buildFiles: [package.json]
-srcDirs: [src/, app/, lib/]
-
-# Grep 模式
-grepPatterns:
-  import: "import.*from|require\\("
-  export: "module.exports|exports\\.|export (default|const|function|class)"
-  route: "@Controller|@Get|@Post|router\\.(get|post|put|delete)"
-```
-
-**分析输出**：
-- 模块导入/导出列表
-- 路由定义位置
-- Controller 位置
-
-### 3.3 Python 项目分析
-
-```yaml
-# 使用 sourceAnalysis.python 规则
-buildFiles: [requirements.txt, pyproject.toml]
-srcDirs: [src/, app/, backend/]
-
-# Grep 模式
-grepPatterns:
-  import: "^import|^from.*import"
-  class: "^class\\s+(\\w+)"
-  route: "@app\\.route|@router\\.route|@api\\.route"
-```
-
-**分析输出**：
-- 模块依赖关系
-- 类定义列表
-- API 路由位置
-
-### 3.4 Go 项目分析
-
-```yaml
-# 使用 sourceAnalysis.go 规则
-buildFiles: [go.mod]
-srcDirs: [cmd/, internal/, pkg/]
-
-# Grep 模式
-grepPatterns:
-  package: "^package\\s+(\\w+)"
-  func: "^func\\s+(\\w+)"
-  struct: "type\\s+(\\w+)\\s+struct"
-```
-
-**分析输出**：
-- 包结构
-- 函数列表
-- 结构体定义
-
-### 3.5 Rust 项目分析
-
-```yaml
-# 使用 sourceAnalysis.rust 规则
-buildFiles: [Cargo.toml]
-srcDirs: [src/]
-
-# Grep 模式
-grepPatterns:
-  module: "^mod\\s+(\\w+)"
-  fn: "^pub\\s+fn\\s+(\\w+)"
-  struct: "^pub\\s+struct\\s+(\\w+)"
-```
-
-**分析输出**：
-- 模块结构
-- 公共函数列表
-- 结构体定义
-
-### 3.6 项目间依赖分析
-
-**【强制】** 使用 `modelDrivenDetection.stages.dependencyAnalysis` 分析项目间依赖：
-
-```
-你是一个依赖关系分析专家。请分析项目间的调用和依赖关系。
-
-## 探索工具
-
-使用以下工具进行探索：
-- grep: 搜索构建依赖、RPC 引用、HTTP 客户端调用
-- read: 读取构建文件和配置
-
-## 探索步骤
-
-1. 构建依赖分析：grep <dependency>, workspaces
-2. RPC 服务引用：grep @RpcReference, XxxFacade
-3. HTTP 客户端调用：grep RestTemplate, HttpClient, fetch, axios
-4. 共享代码分析：find common, shared, core
-
-## 输出
-
-生成依赖关系图，包含：projectDependencies, sharedModules, externalDependencies
-```
-
-**输出文件**：`03-design-knowledge/02-architecture/service-dependency-graph.md`
-
----
-
-## Step 4: 提取架构设计（AI 驱动）
-
-**【强制】** 基于 Step 2 扫描结果和 Step 3 源码分析，提取架构信息：
-
-### 4.1 识别架构文档
-
-- 检查是否已有架构设计文档（`*architecture*.md`, `*design*.md`）
-- 有文档 → 直接复制到 `03-design-knowledge/02-architecture/`
-- 无文档 → 进入 4.2 AI 提取
-
-### 4.2 AI 提取架构信息
-
-**输入**：
-- Step 1 的框架识别结果
-- Step 3 的源码分析结果（包结构、类列表、注解位置）
-
-**使用模板**：`knowledge/09-templates/01-architecture-design.md`
-
-**生成内容**：
-1. 架构愿景（从项目 README、package.json description 提取）
-2. 逻辑架构（从包结构、模块依赖推断）
-3. 技术选型（从 frameworks 识别结果）
-4. 质量属性（从配置推断）
-
-**输出文件**：`03-design-knowledge/02-architecture/{project-name}-architecture.md`
-
----
-
-## Step 5: 提取接口定义（AI 驱动）
-
-**【强制】** 提取接口定义：
-
-### 5.1 识别 OpenAPI/Swagger 文件
-
-- 扫描 `openapi.yaml`, `openapi.json`, `swagger.yaml`, `swagger.json`
-- 找到 → 复制到 `03-design-knowledge/03-api/`
-- 无 → 进入 5.2 代码提取
-
-### 5.2 从代码提取接口
-
-**【强制】** 使用 `modelDrivenDetection.stages.apiDiscovery` 进行深度检测：
-
-**Java (Spring + RPC)**：
-```bash
-# 提取 HTTP @RestController 和 @Controller
-grep -r "@RestController\|@Controller" --include="*.java"
-# 提取 @RequestMapping 等
-grep -r "@GetMapping\|@PostMapping\|@PutMapping\|@DeleteMapping" --include="*.java"
-
-# 提取 RPC @RpcProvider 服务
-grep -r "@RpcProvider" --include="*.java" -A 5
-# 提取 Facade 接口定义
-grep -r "interface.*Facade" --include="*.java"
-# 提取 RPC 引用
-grep -r "@RpcReference" --include="*.java"
-```
-
-**Node.js (Express/NestJS)**：
-```bash
-# 提取路由定义
-grep -r "router\.\(get\|post\|put\|delete\)" --include="*.js" --include="*.ts"
-# 提取 NestJS Controller
-grep -r "@Controller\|@Get\|@Post" --include="*.ts"
-```
-
-**Python (FastAPI/Flask)**：
-```bash
-# 提取路由
-grep -r "@app\.route\|@router\.route" --include="*.py"
-# 提取 FastAPI 端点
-grep -r "@app\.get\|@app\.post" --include="*.py"
-```
-
-**模型驱动深度检测**：
-
-```
-你是一个 API 接口分析专家。请发现项目中所有的 HTTP 和 RPC 接口。
-
-## 探索工具
-
-使用以下工具进行探索：
-- grep: 搜索注解和路由定义
-- read: 读取 Controller/Facade 类
-
-## 探索步骤
-
-1. HTTP 接口检测：grep @RestController, @GetMapping 等
-2. RPC 接口检测：grep @RpcProvider, interface.*Facade
-3. OpenAPI 检测：find openapi*.yaml, swagger*.yaml
-4. 读取接口定义：读取类文件提取方法签名
-
-## 输出
-
-生成 HTTP 和 RPC 接口列表，包含：controller, basePath, endpoints, methods
-```
-
-**使用模板**：`knowledge/09-templates/02-api-design.md`
-
-**输出文件**：`03-design-knowledge/03-api/{api-name}.md`
-
----
-
-## Step 6: 提取数据模型（AI 驱动）
-
-**【强制】** 提取数据库/数据模型设计：
-
-### 6.1 识别 Schema 文件
-
-- 扫描 `*.sql`, `*.ddl`, `schema.sql`
-- 扫描 ORM 模型文件（`*model*.py`, `*entity*.java`, `*model*.ts`）
-
-### 6.2 提取表结构
-
-**SQL 文件**：
-```bash
-# 提取 CREATE TABLE
-grep -A 20 "CREATE TABLE" --include="*.sql"
-```
-
-**ORM 模型**：
-- Java: `@Entity` 注解的类
-- Python: `class *(db.Model)` 或 `class *(Model)`
-- Node.js: `mongoose.model` 或 `sequelize.model`
-
-### 6.3 AI 生成数据模型文档
-
-**使用模板**：`knowledge/09-templates/03-database-design.md`
-
-**生成内容**：
-1. 概念模型（ER 图）
-2. 逻辑模型（表结构）
-3. 物理模型（索引、分区）
-
-**输出文件**：`03-design-knowledge/04-database/schema-design.md`
-
----
-
-## Step 7: 生成知识文件（按模板）
-
-**【强制】** 使用对应模板生成知识文件：
-
-### 7.1 环境知识
-
-**中间件知识**：
-- 模板：`knowledge/09-templates/10-middleware-knowledge.md`
-- 输出目录：`01-env-knowledge/middleware/`
-- 生成文件：每个检测到的中间件生成一个 `.md` 文件
-
-**基础设施知识**：
-- 输出目录：`01-env-knowledge/infrastructure/`
-
-**环境变量**：
-- 输出目录：`01-env-knowledge/env-variables/`
-
-### 7.2 组件库知识
-
-**组件知识**：
-- 模板：`knowledge/09-templates/08-component-knowledge.md`
-- 输出目录：`02-component-lib/components/`
-- 生成文件：每个组织组件生成 `{component-name}/component.md`
-
-**最佳实践**：
-- 模板：`knowledge/09-templates/09-best-practices.md`
-- 输出目录：`02-component-lib/best-practices/`
-
-### 7.3 设计知识
-
-**产品设计**：
-- 模板：`knowledge/09-templates/00-requirement-proposal.md`, `knowledge/09-templates/04-product-design.md`
-- 输出目录：`03-design-knowledge/product/`
-
-**架构设计**：
-- 模板：`knowledge/09-templates/01-architecture-design.md`
-- 输出目录：`03-design-knowledge/architecture/`
-
-**API 设计（含 RPC）**：
-- 模板：`knowledge/09-templates/02-api-design.md`
-- 输出目录：`03-design-knowledge/api/`
-- 说明：HTTP API 和 RPC 服务统一输出到此目录
-
-**数据库设计**：
-- 模板：`knowledge/09-templates/03-database-design.md`
-- 输出目录：`03-design-knowledge/database/`
-
-### 7.4 业务知识（含数据模型）
-
-**领域业务知识**：
-- 模板：`knowledge/09-templates/05-domain-business.md`
-- 输出目录：`04-business-knowledge/`
-- 生成文件：`{domain-name}.md`
-- 整合内容：业务术语表、业务规则、业务流程、领域模型（含数据模型）、实体详情
-
-### 7.5 测试知识
-
-**测试设计**：
-- 模板：`knowledge/09-templates/06-test-design.md`
-- 输出目录：`05-test-knowledge/test-designs/`
-
-**评测设计**：
-- 模板：`knowledge/09-templates/07-evaluation-design.md`
-- 输出目录：`05-test-knowledge/evaluation/`
-
----
-
-## Step 8: 模板合规校验
-
-**【强制】** 对生成的每个知识文件执行模板校验：
-
-### 8.1 章节完整性检查
-
-| 知识类型 | 必填章节 |
-|---------|---------|
-| 中间件 | 基本信息、环境变量、连接代码模板、依赖信息、配置项详解、实际使用代码 |
-| 组件 | 基本信息、接口定义、使用示例 |
-| 架构设计 | 架构愿景、逻辑架构、技术选型、服务依赖关系 |
-| API 设计 | 接口概述、端点设计、RPC 接口设计、错误处理 |
-| 数据库设计 | 概念模型、逻辑模型、物理模型、数据模型知识 |
-| 领域业务 | 业务术语表、业务规则、业务流程、领域模型、实体详情 |
-
-### 8.2 表格格式校验
-
-- 表格必须有表头行
-- 表格列数必须一致
-- 必填表格不能为空
-
-### 8.3 类型枚举校验
-
-- 中间件类型必须在预定义枚举中
-- 组件类型必须在预定义枚举中
-
-### 8.4 生成校验报告
-
-```
-🔍 模板合规检查
-
-中间件：5 文件
-  ✅ mysql.md - 符合模板规范
-  ✅ redis.md - 符合模板规范
-  ⚠️  kafka.md - 缺少「连接代码模板」章节
-
-设计知识：3 文件
-  ✅ architecture.md - 符合模板规范
-  ✅ api.md - 符合模板规范
-
-总计：8 文件，7 完全合规，1 有警告
-```
-
----
-
-## Step 9: 注册激活
-
-**【强制】** 将知识注册到 registry.json：
-
-### 9.1 更新注册表
-
-```json
-{
-  "environmentKnowledge": {
-    "middleware": [
-      {"file": "01-env-knowledge/middleware/mysql.md", "auto": true}
-    ]
-  },
-  "designKnowledge": {
-    "architecture": [
-      {"file": "03-design-knowledge/architecture/project-architecture.md", "auto": true}
-    ],
-    "api": [
-      {"file": "03-design-knowledge/api/chat-api.md", "auto": true}
-    ]
-  },
-  "businessKnowledge": [
-    {"file": "04-business-knowledge/chat-domain.md", "auto": true}
-  ]
-}
-```
-
-### 9.2 生成同步报告
-
-```
-✅ 环境知识同步完成
-
-目录结构:
-  ✅ 01-env-knowledge/
-  ✅ 02-component-lib/
-  ✅ 03-design-knowledge/
-  ✅ 04-business-knowledge/
-  ✅ 05-test-knowledge/
-  ✅ 06-standards/
-  ✅ 07-guides/
-  ✅ 08-integration/
-
-扫描结果:
-  语言：Java (Maven)
-  框架：Spring Boot, Dubbo
-  中间件：MySQL, Redis, Kafka
-  设计文档：3 个
-  测试文档：1 个
-  业务知识：2 个
-
-生成知识:
-  环境知识：5 文件
-  组件库：2 文件
-  设计知识：4 文件
-  业务知识：2 文件
-  测试知识：2 文件
-
-校验结果:
-  ✅ 15 文件完全合规
-  ⚠️  1 文件有警告
-
-下一步:
-  1. 检查生成的知识文件
-  2. 执行 /autospec:env-validate 验证配置
-  3. 执行 /autospec:env-update --dry-run 预览变更
-```
-
----
-
-## Step 10: 增量同步检测
-
-**【强制】** 检测是否需要增量同步：
-
-### 10.1 检测变更
-
-**依赖变更检测**：
-```bash
-# 检测 pom.xml/package.json 变更
-git diff --name-only HEAD~1 HEAD -- "**/pom.xml" "**/package.json" "**/go.mod" "**/requirements.txt"
-```
-
-**代码变更检测**：
-```bash
-# 检测关键代码变更
-git diff --name-only HEAD~1 HEAD -- "**/*.java" "**/*.py" "**/*.ts" "**/*.go"
-```
-
-**配置变更检测**：
-```bash
-# 检测配置文件变更
-git diff --name-only HEAD~1 HEAD -- "**/application*.properties" "**/application*.yml" "**/*.env"
-```
-
-### 10.2 增量同步策略
-
-| 变更类型 | 同步范围 | 说明 |
-|---------|---------|------|
-| 依赖变更 | 仅更新受影响的中间件知识 | 解析新增/删除的依赖 |
-| 代码变更 | 仅更新受影响的 RPC 服务/数据模型知识 | 重新扫描变更文件 |
-| 配置变更 | 仅更新受影响的配置项 | 提取新的配置项 |
-| 无变更 | 跳过同步 | 输出「无变更」提示 |
-
-### 10.3 增量同步输出
-
-```json
-{
-  "mode": "incremental",
-  "changes": {
-    "dependencies": ["新增: redis-client"],
-    "code": ["修改: ChatController.java"],
-    "config": ["新增: cache.ttl"]
-  },
-  "affectedKnowledge": [
-    "01-env-knowledge/middleware/redis.md"
-  ],
-  "skipped": ["mysql.md", "kafka.md"]
-}
-```
-
-### 10.4 强制全量同步
-
-用户可指定 `--full` 参数强制全量同步：
-
-```bash
-/autospec:env-sync --full
-```
-
----
-
-## 产出物
-
-- `.autospec/environment/` 精简目录结构
-- `.autospec/runtime/env-scan-result.json` 扫描结果
-- `.autospec/environment/01-env-knowledge/`
-  - `middleware/*.md`           # 中间件知识（含外部服务）
-  - `infrastructure/*.md`       # 基础设施知识
-  - `env-variables/`            # 环境变量
-- `.autospec/environment/02-component-lib/`
-  - `components/*/component.md` # 组件知识
-  - `best-practices/*.md`       # 最佳实践
-- `.autospec/environment/03-design-knowledge/`
-  - `product/*.md`              # 产品设计
-  - `architecture/*.md`         # 架构设计（含服务依赖）
-  - `api/*.md`                  # API 设计（含 RPC）
-  - `database/*.md`             # 数据库设计
-- `.autospec/environment/04-business-knowledge/`
-  - `{domain-name}.md`          # 领域业务知识（含数据模型）
-- `.autospec/environment/05-test-knowledge/`
-  - `test-designs/*.md`         # 测试设计
-  - `evaluation/*.md`           # 评测设计
-- `.autospec/environment/registry.json` 知识注册表
-- `.autospec/environment/knowledge-source.json` 知识来源配置
-
----
-
-## 输出结果
-
-```
-✅ 环境知识同步完成
-
-初始化:
-  .autospec/environment/     精简目录结构
-
-模板加载:
-  检测规则：01-detection-patterns.yaml
-  中间件模板：10-middleware-knowledge.md（含外部服务）
-  组件模板：08-component-knowledge.md
-  最佳实践模板：09-best-practices.md
-  设计模板：01-architecture-design.md（含服务依赖）, 02-api-design.md（含RPC）, 03-database-design.md（含数据模型）
-  业务模板：05-domain-business.md（整合术语/规则/流程/领域模型/数据模型）
-  测试模板：06-test-design.md, 07-evaluation-design.md
-
-扫描结果:
-  语言：{language}
-  框架：{frameworks}
-  中间件：{middleware_count} 项
-  设计文档：{design_docs_count} 项
-  测试文档：{test_docs_count} 项
-  业务知识：{business_docs_count} 项
-
-生成知识:
-  环境知识：{env_files} 文件
-  组件库：{component_files} 文件
-  设计知识：{design_files} 文件
-  业务知识：{business_files} 文件
-  测试知识：{test_files} 文件
-
-校验结果:
-  ✅ {compliant_count} 文件完全合规
-  ⚠️  {warning_count} 文件有警告
-
-下一步:
-  1. 检查生成的知识文件
-  2. 执行 /autospec:env-validate 验证配置
-  3. 执行 /autospec:env 查看环境状态
-```