@dtt_siye/atool 1.3.0 → 1.3.1

package/skills/project-analyze/rules/generic.md

@@ -1,243 +1,75 @@
 # 通用项目分析规则
 
-当无法识别具体技术栈或项目结构不遵循常见框架模式时使用此规则。作为所有规则文件的兜底。
+当无法识别具体技术栈或项目不遵循常见框架模式时使用。作为所有规则文件的兜底。
 
-## 分析粒度
+> **编码规范**：generic 无对应 conventions skill，Phase 2.5 精炼阶段跳过规范约束加载。
 
-按目录结构、文件类型和模块边界进行通用分析。
+## 模块发现策略
 
-```
-项目根目录
-    ├── 配置文件（package.json, Makefile, Cargo.toml 等）
-    ├── src/ 或 lib/（源码目录）
-    │   ├── 模块 A
-    │   ├── 模块 B
-    │   └── 公共代码
-    ├── tests/ 或 test/（测试目录）
-    ├── docs/（文档目录）
-    └── scripts/（脚本目录）
-```
-
-## 目录扫描策略
+**信号文件优先级检测**（用于推断技术栈，再路由到对应规则）：
 
-### 1. 识别项目类型
+| 信号文件 | 推断技术栈 |
+|---------|----------|
+| `package.json` | Node.js / JavaScript |
+| `pyproject.toml` / `requirements.txt` | Python |
+| `go.mod` | Go |
+| `Cargo.toml` | Rust |
+| `pom.xml` / `build.gradle` | Java |
+| `Gemfile` | Ruby |
+| `composer.json` | PHP |
+| `Makefile` / `CMakeLists.txt` | C/C++ |
+| `pubspec.yaml` | Dart / Flutter |
+| 无信号文件 | 按目录结构推断（见下） |
 
-**信号文件检测（按优先级）：**
-- `package.json` → Node.js / JavaScript 项目
-- `pyproject.toml` / `requirements.txt` → Python 项目
-- `go.mod` → Go 项目
-- `Cargo.toml` → Rust 项目
-- `pom.xml` / `build.gradle` → Java 项目
-- `Gemfile` → Ruby 项目
-- `composer.json` → PHP 项目
-- `Makefile` / `CMakeLists.txt` → C/C++ 项目
-- `build.gradle.kts` → Kotlin 项目
-- `pubspec.yaml` → Dart/Flutter 项目
-- 无信号文件 → 按目录结构推断
+**通用目录模块发现规则**（无法路由到具体规则时）：
+- `src/` 下每个一级子目录视为一个功能模块
+- 包含 3+ 源码文件的目录视为独立模块
+- 单文件项目作为一个整体模块分析
+- 递归扫描最大深度 3 层
 
-### 2. 排除非源码目录
-
-```
-node_modules/     vendor/       build/        dist/
-.git/             __pycache__/  .cache/        target/
-.idea/            .vscode/      .settings/    .DS_Store
-.venv/            venv/         env/           oh_modules/
-*.egg-info/       .eggs/        coverage/      .next/
-out/              bin/          obj/           .gradle/
-```
+排除目录：`node_modules/`, `vendor/`, `build/`, `dist/`, `.git/`, `__pycache__/`, `target/`, `.venv/`, `venv/`, `.next/`, `out/`
 
-### 3. 按层扫描路径
+## 入口识别
 
-- **入口**: `src/main.*`, `src/index.*`, `index.*`, `main.*`, `app.*`
-- **公共代码**: `src/common/`, `src/shared/`, `src/core/`, `src/base/`
-- **业务模块**: `src/modules/`, `src/features/`, `src/domain/`
-- **工具**: `src/utils/`, `src/helpers/`, `src/lib/`, `src/internal/`
-- **类型**: `src/types/`, `src/interfaces/`, `src/schemas/`
-- **配置**: `src/config/`, `config/`, `conf/`
-- **测试**: `tests/`, `test/`, `__tests__/`, `src/test/`
+按优先级尝试：
+1. `src/main.*`, `src/index.*`, `index.*`, `main.*`, `app.*`
+2. 配置文件中的 `main` / `entry` / `bin` 字段（package.json、Cargo.toml 等）
+3. `Makefile` / `Taskfile` 的默认 target
+4. 无入口时：以所有顶级源码文件为入口节点
 
-## 各层提取规则
+## 架构模式识别
 
-### 层 1: 入口分析
+- **分层结构**：检测 `src/domain/`, `src/application/`, `src/infrastructure/` 模式（DDD / Clean Architecture）
+- **模块聚合**：检测 `src/modules/`, `src/features/` 模式（Feature-based 组织）
+- **核心-插件**：检测 `src/core/` + `src/plugins/` 模式
+- **公共层识别**：`src/common/`, `src/shared/`, `src/utils/` — 合并为一个"公共"模块，不单独拆分
 
-**扫描文件**: 项目根目录下的入口文件
+## 数据流模式
 
-**提取内容**:
-- 入口文件路径和语言
-- 导入的模块列表
-- 初始化逻辑摘要
-- 暴露的公开 API
+- 扫描 import / require 语句建立模块依赖图
+- 识别单向数据流（入口 → 业务逻辑 → 数据访问 → 外部 IO）
+- 检测循环依赖（A → B → A）标记为需关注问题
 
-**输出示例**:
-```
-### 入口文件
-- **文件**: `src/index.ts`
-- **语言**: TypeScript
-- **导入模块**: ./config, ./core/App, ./routes
-- **公开 API**:
-  | 名称 | 类型 | 说明 |
-  |------|------|------|
-  | createApp | (config: AppConfig) => App | 创建应用实例 |
-  | version | string | 版本号 |
-```
+## 分析关注点
 
-### 层 2: 模块发现
+1. **模块边界清晰度**：目录命名是否反映业务职责，还是技术类型（`utils/` vs `user-service/`）
+2. **依赖方向**：是否存在底层模块依赖高层模块的逆向依赖
+3. **入口清晰度**：是否有明确的应用入口，还是分散在多个文件中
+4. **构建可重现性**：是否有锁文件（`package-lock.json`, `Cargo.lock`, `go.sum`）
+5. **测试覆盖信号**：是否存在 `tests/`, `__tests__/`, `*.test.*` 目录，测试比例粗估
 
-**扫描规则**:
-- 递归扫描源码目录（最大深度 3 层）
-- 每个包含 3+ 源码文件的目录视为一个功能模块
-- `src/` 下的每个一级子目录为一个模块
-- 单文件项目作为一个整体模块
+## 输出示例
 
-**输出示例**:
 ```
 ### 模块列表
-| 模块 | 路径 | 文件数 | 主要语言 | 职责描述 |
-|------|------|--------|----------|----------|
-| core | src/core/ | 12 | TypeScript | 核心逻辑和框架 |
-| utils | src/utils/ | 8 | TypeScript | 工具函数集合 |
-| api | src/api/ | 6 | TypeScript | 外部 API 封装 |
-| models | src/models/ | 4 | TypeScript | 数据模型定义 |
-```
-
-### 层 3: 核心类/函数分析
-
-**扫描文件**: 每个模块内的主要源码文件
-
-**提取内容**:
-- 类/函数/接口名称
-- 签名（参数 + 返回类型）
-- 职责描述
-- 依赖的其他模块
-
-**输出示例**:
-```
-### 核心导出
-- **文件**: `src/core/engine.ts`
-- **导出**:
-  | 名称 | 类型 | 签名 | 说明 |
-  |------|------|------|------|
-  | Engine | Class | constructor(config: Config) | 核心引擎类 |
-  | process | Method | (input: Data): Promise<Result> | 处理数据 |
-  | validate | Function | (data: unknown): data is ValidData | 数据校验 |
-- **依赖**: `src/config`, `src/utils/logger`, `src/models`
-```
-
-### 层 4: 依赖分析
-
-**扫描文件**: 各种包管理器的依赖文件
-
-**提取内容**:
-- 依赖管理器类型和版本
-- 运行时依赖列表（名称 + 版本）
-- 开发依赖列表
-- 对等依赖（peerDependencies）
-
-**输出示例**:
-```
-### 依赖信息
-- **管理器**: npm (package.json)
-- **运行时依赖**:
-  | 包名 | 版本 | 用途 |
-  |------|------|------|
-  | express | 4.18.2 | Web 框架 |
-  | zod | 3.22.4 | 数据验证 |
-  | dayjs | 1.11.9 | 日期处理 |
-```
+| 模块   | 路径         | 文件数 | 主要语言    | 职责描述       |
+|-------|-------------|-------|-----------|--------------|
+| core  | src/core/   | 12    | TypeScript | 核心逻辑和框架 |
+| utils | src/utils/  | 8     | TypeScript | 工具函数集合   |
+| api   | src/api/    | 6     | TypeScript | 外部 API 封装  |
 
-### 层 5: 构建与配置分析
-
-**扫描文件**: 配置文件、构建脚本
-
-**提取内容**:
-- 构建命令（build、test、lint、dev）
-- 环境变量配置
-- 关键配置项
-
-**输出示例**:
-```
-### 构建配置
-- **构建工具**: TypeScript + tsx
-- **脚本命令**:
-  | 命令 | 执行内容 | 说明 |
-  |------|----------|------|
-  | npm run dev | tsx watch src/index.ts | 开发模式 |
-  | npm run build | tsc && node build.js | 生产构建 |
-  | npm run test | vitest run | 运行测试 |
-  | npm run lint | eslint src/ --ext .ts | 代码检查 |
-```
-
-## 输出模板
-
-### README.md 章节结构
-
-```markdown
-# {项目名}
-
-## 项目概述
-项目功能描述（从 README 或配置文件 description 提取）
-
-## 技术栈
-| 技术 | 版本 | 用途 |
-|------|------|------|
-
-## 架构设计
-### 架构图（ASCII）
-展示模块关系的 ASCII 图
-
-### 目录结构
-带注释的文件树
-
-## 模块说明
-每个模块的职责、核心 API、依赖关系
-
-## 构建 & 运行
-构建命令、环境变量、运行方式
-
-## 开发指南
-如何修改/扩展项目
-```
-
-### COMPONENT.md 章节结构
-
-```markdown
-# 模块文档
-
-## 模块索引
-按功能分组的模块列表
-
-## 各模块详情
-### {模块名}
-- 路径 + 语言
-- 公开 API 表格
-- 依赖关系
-- 使用示例
+### 入口文件
+- **文件**: `src/index.ts`
+- **导入模块**: ./config, ./core/App, ./routes
+- **公开 API**: createApp(config), version
 ```
-
-## 模块边界识别
-
-以下目录模式下的每个子目录视为独立模块（L2+ 分析时生成 MODULE-DOC.md）：
-
-| 层 | 扫描路径 | 模块判定规则 | MODULE-DOC slug 来源 |
-|----|----------|-------------|---------------------|
-| 源码层 | `src/` 一级子目录 | 3+ 文件的子目录 | 目录名 kebab-case |
-| API/服务层 | `src/api/`, `src/services/` | 每个子目录 | 目录名 kebab-case |
-| 状态管理层 | `src/store/`, `src/state/` | 每个子目录 | 目录名 kebab-case |
-| 组件层 | `src/components/` | 3+ 文件的子目录 | 目录名 kebab-case |
-| 自动推断 | 其他目录 | 3+ 源码文件 | 目录名 kebab-case |
-
-**不视为独立模块的情况**：
-- 单文件入口（如 `main.ts`, `index.js`, `app.py`）
-- 纯导出桶文件（仅有 re-export）
-- 工具函数目录（`utils/`, `helpers/`, `lib/`）— 合并为一个模块
-- 生成文件（`*.generated.*`, `*.min.*`）跳过
-
-## Token 管理
-
-- 大目录（>20 文件）拆分为子任务
-- 每个子任务分析 ≤10 文件
-- 二进制文件、图片、压缩包跳过
-- 超大文件（>100KB）跳过内容分析，只记录文件名和大小
-- 生成文件（`*.generated.*`, `*.min.*`）跳过
-- 测试文件单独分组分析
-- 配置文件（JSON/YAML/TOML）单独分析

package/skills/project-analyze/rules/go.md

@@ -1,289 +1,74 @@
 # Go 项目分析规则
 
-## 分析粒度
-
-按 Go package（目录）和分层架构（Handler → Service → Repository → Model）进行分析。
-
-```
-cmd/（入口）
-    ↓
-internal/
-    ├── handler/（HTTP 处理器）
-    ├── service/（业务逻辑）
-    ├── repository/（数据访问）
-    ├── model/（数据模型）
-    ├── middleware/（中间件）
-    └── config/（配置）
-    ↓
-pkg/（可导出公共包）
-    ↓
-api/（API 定义）
-```
-
-## 目录扫描策略
-
-### 1. 识别项目布局
-
-**信号文件检测：**
-- `go.mod` → Go Module
-- `go.sum` → 依赖锁定
-- `main.go` → 可执行程序
-- 按 golang-standards/project-layout 组织
-
-### 2. 识别项目类型
-
-- **Web API**: `gin`, `echo`, `fiber`, `chi` 依赖
-- **gRPC**: `google.golang.org/grpc`, `protobuf` 依赖
-- **CLI**: `cobra`, `urfave/cli` 依赖
-- **微服务**: `go-micro`, `kratos` 依赖
-
-### 3. 依赖提取
-
-从 `go.mod` 提取：
-
-| 类别 | 常见依赖 |
+> **编码规范**：本规则不包含编码规范内容。Phase 2.5 精炼阶段会自动加载 `go-conventions` skill 作为规范约束。
+
+## 模块发现策略
+
+- **Go Module**：从 `go.mod` 读取 module 名和 Go 版本
+- **标准布局**（golang-standards/project-layout）：
+  - `cmd/{name}/` — 每个子目录为一个可执行模块
+  - `internal/{name}/` — 每个子目录为一个内部包模块
+  - `pkg/{name}/` — 每个子目录为一个可导出包模块
+- **非标准布局**：按目录内 `.go` 文件数量判断（3+ 文件视为独立模块）
+- **跳过**：`vendor/`、`*_gen.go`、`*.pb.go`、`*_test.go`（单独分组分析）
+
+项目类型检测（从 `go.mod` 依赖判断）：
+- Web API：`gin` / `echo` / `fiber` / `chi`
+- gRPC：`google.golang.org/grpc` + `protobuf`
+- CLI：`cobra` / `urfave/cli`
+- 微服务：`go-micro` / `kratos`
+
+## 入口识别
+
+| 标记 | 含义 |
+|------|------|
+| `cmd/*/main.go` | 各可执行程序入口 |
+| `func main()` | 应用启动入口（初始化顺序：config → logger → db → server） |
+| `r.GET/POST/...` / `e.GET/POST/...` | HTTP 路由注册（Gin / Echo） |
+| `pb.Register*Server()` | gRPC 服务注册入口 |
+| `cobra.Command.Run` | CLI 子命令入口 |
+| `go func()` / `goroutine` 启动点 | 异步任务入口 |
+
+## 架构模式识别
+
+| 模式 | 检测特征 |
 |------|----------|
-| Web 框架 | gin, echo, fiber, chi |
-| gRPC | google.golang.org/grpc |
-| ORM | gorm, sqlx, ent |
-| 配置 | viper, envconfig |
-| 日志 | zap, logrus, zerolog |
-| 测试 | testify, mockgen |
-| 数据库驱动 | pgx, go-sql-driver/mysql |
-| 缓存 | go-redis |
-| 消息队列 | amqp, sarama |
-| DI | wire, fx |
-| 验证 | go-playground/validator |
-
-### 4. 按层扫描路径
-
-- **入口**: `cmd/` 下的 main.go
-- **Handler**: `internal/handler/`, `internal/http/`, `internal/controller/`
-- **Service**: `internal/service/`, `internal/usecase/`, `internal/biz/`
-- **Repository**: `internal/repository/`, `internal/store/`, `internal/data/`
-- **Model**: `internal/model/`, `internal/domain/`, `internal/entity/`
-- **Middleware**: `internal/middleware/`
-- **Config**: `internal/config/`, `config/`
-- **公共包**: `pkg/` 下的子目录
-- **API 定义**: `api/` (Protobuf / OpenAPI)
-
-## 各层提取规则
+| 标准分层 | `handler/` + `service/` + `repository/` + `model/` 目录并存 |
+| Clean/Hexagonal | `domain/` + `usecase/` + `infrastructure/` 分离 |
+| Kratos 框架 | `internal/biz/` + `internal/data/` + `internal/service/` |
+| 单一 package | 所有代码在 `main` package，无子目录分层 |
+| Interface 驱动 | 每层定义 interface，`wire` / `fx` 进行依赖注入 |
 
-### 层 1: Handler 层
+## 数据流模式
 
-**扫描文件**: `internal/handler/*.go`, `internal/http/*.go`
+- **HTTP 请求链**：Middleware → Handler → Service → Repository → DB
+- **gRPC 请求链**：Interceptor → gRPC Handler → UseCase → Repository → DB
+- **异步任务链**：goroutine → Channel → Worker → Repository → DB
+- **消息消费链**：Kafka/AMQP Consumer → Service → Repository → DB
 
-**提取内容**:
-- Handler 函数签名
-- 路由注册（路由路径 + HTTP 方法 + Handler 函数）
-- 请求/响应结构体
-- 使用的 Service
-- 中间件链
+## 分析关注点
 
-**输出示例**:
-```
-### UserHandler
-- **路径**: `internal/handler/user_handler.go`
-- **依赖注入**: UserService (interface)
-- **Handler 方法**:
-  | 方法 | 签名 | 说明 |
-  |------|------|------|
-  | CreateUser | (c *gin.Context) | 创建用户 |
-  | GetUser | (c *gin.Context) | 获取用户详情 |
-  | ListUsers | (c *gin.Context) | 分页查询 |
-  | UpdateUser | (c *gin.Context) | 更新用户 |
-  | DeleteUser | (c *gin.Context) | 删除用户 |
-
-### 路由注册
-- **文件**: `internal/router/router.go`
-- **路由表**:
-  | 方法 | 路径 | Handler | 中间件 | 说明 |
-  |------|------|---------|--------|------|
-  | POST | /api/v1/users | CreateUser | Auth, Admin | 创建用户 |
-  | GET | /api/v1/users/:id | GetUser | Auth | 获取用户 |
-  | GET | /api/v1/users | ListUsers | Auth | 用户列表 |
-  | PUT | /api/v1/users/:id | UpdateUser | Auth, Admin | 更新用户 |
-  | DELETE | /api/v1/users/:id | DeleteUser | Auth, Admin | 删除用户 |
-```
-
-### 层 2: Service 层
+- **Interface 边界**：识别 Service / Repository 的 interface 定义，标注实现类（依赖方向关键）
+- **goroutine 泄漏风险**：扫描 `go func()` 未配合 `context.Done()` 或 WaitGroup 的模式
+- **并发原语**：`sync.Mutex` / `sync.RWMutex` / `chan` / `errgroup` 的使用位置和模式
+- **错误传递**：是否使用 `fmt.Errorf("... %w", err)` 包装，还是直接返回裸 error
+- **DI 框架**：`wire` 的 `ProviderSet` 或 `fx.Provide()` 揭示完整依赖图
 
-**扫描文件**: `internal/service/*.go`
+## 输出示例
 
-**提取内容**:
-- Service interface 定义
-- 方法签名（参数 + 返回值）
-- 实现类的业务逻辑摘要
-- 依赖的 Repository / 其他 Service
-
-**输出示例**:
+Handler/路由提取片段：
 ```
-### UserService interface
-- **路径**: `internal/service/user_service.go`
-- **方法**:
-  | 方法 | 签名 | 说明 |
-  |------|------|------|
-  | Create | (ctx, CreateUserReq) (*User, error) | 创建用户（校验+哈希密码+存储） |
-  | GetByID | (ctx, int64) (*User, error) | 按 ID 查询 |
-  | List | (ctx, ListUsersReq) ([]*User, int64, error) | 分页列表（返回总数） |
-  | Update | (ctx, int64, UpdateUserReq) (*User, error) | 更新用户 |
-  | Delete | (ctx, int64) error | 删除用户 |
-- **实现**: userServiceImpl
-- **依赖**: UserRepository, PasswordEncoder, CacheService
+UserHandler  internal/handler/user_handler.go
+  POST /api/v1/users       → CreateUser()  [Auth, Admin]
+  GET  /api/v1/users/:id   → GetUser()     [Auth]
+  GET  /api/v1/users       → ListUsers()   [Auth]
+  → 依赖注入: UserService (interface)
 ```
 
-### 层 3: Repository 层
-
-**扫描文件**: `internal/repository/*.go`
-
-**提取内容**:
-- Repository interface 定义
-- 数据库操作方法（SQL / GORM / Ent）
-- 数据源类型
-
-**输出示例**:
+并发模式片段：
 ```
-### UserRepository interface
-- **路径**: `internal/repository/user_repository.go`
-- **数据源**: PostgreSQL (pgx)
-- **方法**:
-  | 方法 | 签名 | SQL/GORM | 说明 |
-  |------|------|---------|------|
-  | Create | (ctx, *User) error | INSERT INTO users (...) | 创建 |
-  | FindByID | (ctx, int64) (*User, error) | SELECT * FROM users WHERE id=$1 | 按 ID 查询 |
-  | FindByEmail | (ctx, string) (*User, error) | SELECT * FROM users WHERE email=$1 | 按邮箱查询 |
-  | Update | (ctx, *User) error | UPDATE users SET ... WHERE id=$1 | 更新 |
-  | Delete | (ctx, int64) error | DELETE FROM users WHERE id=$1 | 删除 |
-  | List | (ctx, offset, limit int) ([]*User, int64, error) | SELECT + COUNT | 分页列表 |
+并发分析
+  goroutine: service/notification.go — 异步发送通知（配合 errgroup）
+  sync.Mutex: cache/in_memory.go — 缓存读写锁
+  channel: service/event.go — mpsc::Sender<Event>，生产者: handlers，消费者: event_processor
 ```
-
-### 层 4: Model 层
-
-**扫描文件**: `internal/model/*.go`
-
-**提取内容**:
-- struct 定义（字段 + 类型 + tag）
-- GORM / Ent model 注解
-- 验证 tag（`binding`, `validate`）
-
-**输出示例**:
-```
-### User Model
-- **路径**: `internal/model/user.go`
-- **定义**:
-  ```go
-  type User struct {
-      ID        int64     `json:"id" gorm:"primaryKey;autoIncrement"`
-      Username  string    `json:"username" gorm:"uniqueIndex;size:50;not null" binding:"required,min=3,max=50"`
-      Email     string    `json:"email" gorm:"uniqueIndex;size:100;not null" binding:"required,email"`
-      Password  string    `json:"-" gorm:"size:255;not null" binding:"required,min=6"`
-      Role      string    `json:"role" gorm:"size:20;default:'user'" binding:"omitempty,oneof=admin user"`
-      CreatedAt time.Time `json:"created_at" gorm:"autoCreateTime"`
-      UpdatedAt time.Time `json:"updated_at" gorm:"autoUpdateTime"`
-  }
-  ```
-- **表名**: `users`
-- **索引**: username (unique), email (unique)
-```
-
-### 层 5: 中间件层
-
-**扫描文件**: `internal/middleware/*.go`
-
-**提取内容**:
-- 中间件函数签名
-- 处理链路
-- 应用位置
-
-**输出示例**:
-```
-### 中间件链
-| 顺序 | 中间件 | 用途 | 应用范围 |
-|------|--------|------|----------|
-| 1 | Logger | 请求日志（zap） | 全局 |
-| 2 | Recovery | Panic 恢复 | 全局 |
-| 3 | CORS | 跨域处理 | 全局 |
-| 4 | Auth | JWT Token 验证 | /api/* |
-| 5 | RBAC | 角色权限检查 | 管理接口 |
-```
-
-### 层 6: 并发模式分析
-
-**扫描文件**: 含 `goroutine`, `chan`, `select`, `sync` 的文件
-
-**提取内容**:
-- goroutine 使用场景
-- channel 类型和方向
-- sync 原语（Mutex, WaitGroup, Once）
-
-**输出示例**:
-```
-### 并发模式
-| 模式 | 位置 | 说明 |
-|------|------|------|
-| goroutine + channel | service/notification.go | 异步发送通知 |
-| sync.Mutex | cache/in_memory.go | 缓存读写锁 |
-| sync.WaitGroup | service/batch.go | 批量操作等待 |
-| errgroup | service/sync.go | 并发错误处理 |
-```
-
-## 输出模板
-
-### README.md 章节结构
-
-```markdown
-# {项目名}
-
-## 项目概述
-服务功能描述
-
-## 技术栈
-| 技术 | 版本 | 用途 |
-|------|------|------|
-
-## 架构设计
-### 架构图（ASCII）
-### 数据流图
-
-## 目录结构
-cmd/ internal/ pkg/ 说明
-
-## API 路由
-路由表 + 中间件链
-
-## 数据模型
-struct 定义 + 关系
-
-## 配置
-环境变量 + 配置文件
-
-## 构建 & 运行
-go build / go run / make
-```
-
-## 模块边界识别
-
-以下目录模式下的每个子目录视为独立模块（L2+ 分析时生成 MODULE-DOC.md）：
-
-| 层 | 扫描路径 | 模块判定规则 | MODULE-DOC slug 来源 |
-|----|----------|-------------|---------------------|
-| 命令入口层 | `cmd/{name}/` | 每个子目录 | 目录名 kebab-case |
-| 内部包层 | `internal/{name}/` | 每个子目录 | 目录名 kebab-case |
-| 公共包层 | `pkg/{name}/` | 每个子目录 | 目录名 kebab-case |
-| API 层 | `api/` | 每个文件 | 文件名去后缀 kebab-case |
-| 组件层 | 同 API/内部包层 | 3+ 文件的子目录 | 目录名 kebab-case |
-
-**不视为独立模块的情况**：
-- 单文件入口（如 `main.go`, `cmd/root.go`）
-- 纯导出桶文件（仅有 re-export）
-- 工具函数目录（`util/`, `helper/`）— 合并为一个模块
-- `vendor/` 跳过
-
-## Token 管理
-
-- 大包（>15 文件）拆分为子任务
-- 每个子任务分析 ≤10 文件
-- `go.mod` 依赖分析单独一个子任务
-- 生成文件（`*_gen.go`, `*.pb.go`）可跳过或简要分析
-- `vendor/` 目录跳过
-- `*_test.go` 文件单独分组分析