ai-engineering-init 1.15.0 → 1.16.1

package/.claude/skills/loki-log-query/SKILL.md

@@ -25,81 +25,114 @@ description: |
 
 ## 多环境配置
 
-配置文件：`.claude/skills/loki-log-query/environments.json`
+### 配置文件查找顺序
 
-### 环境列表
+```
+1. 本地项目：.claude/loki-config.json（新格式）
+2. 本地项目：.claude/skills/loki-log-query/environments.json（旧格式，兼容）
+3. 全局配置：~/.claude/loki-config.json
+```
+
+本地配置优先。全局配置推荐用 `npx ai-engineering-init config --type loki --scope global` 创建。
+
+### 配置结构（支持 range 范围匹配）
+
+```json
+{
+  "active": "monitor-dev",
+  "environments": {
+    "monitor-dev": {
+      "name": "Monitor 开发环境",
+      "url": "https://monitor-dev.xnzn.net/grafana",
+      "token": "glsa_xxx",
+      "aliases": ["mdev", "dev"],
+      "range": "dev1~15",
+      "projects": ["dev01","dev02","dev03","dev04","dev05","dev06","dev07","dev08","dev09","dev10","dev11","dev12","dev13","dev14","dev15"]
+    }
+  }
+}
+```
+
+### 环境匹配规则（含 range 范围匹配）
 
-| 环境别名 | 名称 | URL | 快捷词 |
-|----------|------|-----|--------|
-| `test13` | 测试13（主测试环境） | `https://test13.xnzn.net/grafana` | test13, 13 |
-| `monitor-test` | Monitor 测试环境 | `https://monitor-test.xnzn.net/grafana` | mtest |
-| `monitor-dev` | Monitor 开发环境 | `https://monitor-dev.xnzn.net/grafana` | mdev, dev |
-| `monitor02-dev` | Monitor02 开发环境 | `https://monitor02-dev.xnzn.net/grafana` | m02, monitor02 |
-| `monitor-tyy-dev` | Monitor 体验园开发环境 | `https://monitor-tyy-dev.xnzn.net/grafana` | tyy, 体验园 |
+用户说的话 → 匹配逻辑：
 
-### 环境匹配规则
+| 用户说法 | 匹配方式 | 结果 |
+|---------|---------|------|
+| "查 test13 的日志" | 精确匹配 key 或 aliases | `test13` 环境 |
+| "去 dev10 查" | **range 匹配**：dev10 在 monitor-dev 的 projects 中 | `monitor-dev` 环境，`project="dev10"` |
+| "去 monitor-dev 查" | 精确匹配 key | `monitor-dev` 环境 |
+| "切到体验园" | aliases 匹配 | `monitor-tyy-dev` 环境 |
+| 未指定环境 | 使用 `active` 字段 | 默认活跃环境 |
 
-用户说的话 → 匹配环境：
-- "查 test13 的日志" → `test13`
-- "去 monitor-dev 查" → `monitor-dev`
-- "切到体验园" → `monitor-tyy-dev`
-- "去 m02 查一下" → `monitor02-dev`
-- 未指定环境 → 使用 `active` 字段指定的默认环境
+**range 匹配算法**：
+```
+1. 用户输入 "dev10"
+2. 先精确匹配 key / aliases → 未命中
+3. 遍历所有环境的 projects 列表，检查是否包含 "dev10"
+4. 命中 → 使用该环境，并自动添加 project="dev10" 标签过滤
+```
 
-### 读取配置
+### 读取配置（含全局降级 + range 匹配）
 
 ```bash
-SKILL_DIR="$CLAUDE_PROJECT_DIR/.claude/skills/loki-log-query"
-ENV_FILE="${SKILL_DIR}/environments.json"
-
-# 读取指定环境（参数: 环境别名）
-read_env() {
-  local ENV_KEY="${1:-$(python3 -c "import json; print(json.load(open('${ENV_FILE}'))['active'])")}"
-  GRAFANA_URL=$(python3 -c "import json; print(json.load(open('${ENV_FILE}'))['environments']['${ENV_KEY}']['url'])")
-  TOKEN=$(python3 -c "import json; print(json.load(open('${ENV_FILE}'))['environments']['${ENV_KEY}']['token'])")
-  API="${GRAFANA_URL}/api/datasources/proxy/uid/loki/loki/api/v1"
-  echo "Environment: ${ENV_KEY} → ${GRAFANA_URL}"
+# 按优先级查找配置文件
+find_config() {
+  local PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+  for f in \
+    "${PROJECT_DIR}/.claude/loki-config.json" \
+    "${PROJECT_DIR}/.claude/skills/loki-log-query/environments.json" \
+    "${HOME}/.claude/loki-config.json"; do
+    [ -f "$f" ] && echo "$f" && return
+  done
+  echo ""
 }
 
-# 通过别名查找环境 key
+ENV_FILE=$(find_config)
+
+# 通过别名或 range 查找环境 key + project
 find_env() {
   python3 -c "
-import json
+import json, re
 data = json.load(open('${ENV_FILE}'))
 alias = '${1}'.lower()
+# 1. 精确匹配 key 或 aliases
 for key, env in data['environments'].items():
     if alias == key or alias in env.get('aliases', []):
-        print(key)
-        break
-else:
-    print(data['active'])
+        print(f'{key}|')  # key|project（project 为空）
+        exit()
+# 2. range 匹配：在 projects 列表中查找
+for key, env in data['environments'].items():
+    if alias in env.get('projects', []):
+        print(f'{key}|{alias}')
+        exit()
+# 3. 未命中，返回默认
+print(f'{data[\"active\"]}|')
 "
 }
+
+# 使用示例：
+# result=$(find_env "dev10")
+# ENV_KEY=$(echo "$result" | cut -d'|' -f1)   # monitor-dev
+# PROJECT=$(echo "$result" | cut -d'|' -f2)    # dev10
+# 查询时：{app="yunshitang",project="${PROJECT}"}
 ```
 
-### 切换活跃环境
+### 切换活跃环境 / 更新 Token
 
 ```bash
-# 切换默认环境为 monitor-dev
 python3 -c "
 import json
 data = json.load(open('${ENV_FILE}'))
 data['active'] = 'monitor-dev'
 json.dump(data, open('${ENV_FILE}', 'w'), indent=2, ensure_ascii=False)
-print('Switched to:', data['active'])
 "
-```
 
-### 更新 Token
-
-```bash
-# 为某个环境设置 Token
 python3 -c "
 import json
 data = json.load(open('${ENV_FILE}'))
-data['environments']['monitor-dev']['token'] = 'glsa_新的token值'
+data['environments']['monitor-dev']['token'] = 'glsa_新token'
 json.dump(data, open('${ENV_FILE}', 'w'), indent=2, ensure_ascii=False)
-print('Token updated for monitor-dev')
 "
 ```
 

package/.claude/skills/mysql-debug/SKILL.md

@@ -27,22 +27,27 @@ description: |
 
 ---
 
-## 连接信息获取（三级降级，自动查找）
+## 连接信息获取（四级降级，自动查找）
 
 当本技能被激活时，**按以下优先级获取数据库连接信息**：
 
 ### 优先级 1：用户对话中指定（最高优先级）
 
 用户直接给出连接信息，或指定环境名：
-- "连 dev 环境查一下" → 使用 `.claude/mysql-config.json` 中 dev 环境的配置
+- "连 dev 环境查一下" → 使用配置中 dev 环境
+- "去 dev10 查" → **范围匹配** dev 环境（range: "1~15"）
 - 直接给出 host/port/user/password → 直接使用
 
-### 优先级 2：`.claude/mysql-config.json`（显式配置，可选）
+### 优先级 2：本地项目 `.claude/mysql-config.json`
 
-如果文件存在且当前环境的 password 不是占位符 `YOUR_PASSWORD`，使用该配置。
-**此文件为可选**，主要用于连接非本地环境（dev/prod 远程数据库）。
+项目目录下的配置文件，优先于全局配置。
 
-### 优先级 3：工程配置文件（零配置，本地开发默认）
+### 优先级 3：全局 `~/.claude/mysql-config.json`
+
+全局配置文件（通过 `npx ai-engineering-init config --scope global` 创建），所有项目共享。
+**推荐**：公司统一的数据库连接信息放全局，项目特定的覆盖放本地。
+
+### 优先级 4：工程配置文件（零配置，本地开发默认）
 
 从项目的 `bootstrap-dev.yml` 中自动提取连接信息：
 
@@ -107,43 +112,60 @@ brew install mysql-client
 
 ## 多环境支持
 
-### 配置文件结构
+### 配置文件查找顺序
+
+```
+1. 本地项目：.claude/mysql-config.json
+2. 全局配置：~/.claude/mysql-config.json
+```
+
+本地配置优先。如果本地无配置，使用全局。两者都存在时，本地覆盖全局（同名环境取本地值）。
 
-`.claude/mysql-config.json` 支持多环境配置：
+### 配置文件结构（支持 range 范围匹配）
 
 ```json
 {
   "environments": {
-    "local": { "host": "127.0.0.1", "port": 3306, "user": "root", "password": "xxx" },
-    "dev":   { "host": "dev-db.example.com", "port": 3306, "user": "dev_user", "password": "xxx" },
+    "local": { "host": "127.0.0.1", "port": 3306, "user": "root", "password": "xxx", "_desc": "本地环境" },
+    "dev":   { "host": "dev-db.example.com", "port": 3306, "user": "dev_user", "password": "xxx", "range": "1~15", "_desc": "覆盖 dev1→dev15" },
+    "test":  { "host": "test-db.example.com", "port": 3306, "user": "test_user", "password": "xxx", "range": "1~30", "_desc": "覆盖 test1→test30" },
     "prod":  { "host": "prod-db.example.com", "port": 3306, "user": "readonly", "password": "xxx" }
   },
   "default": "local"
 }
 ```
 
+### 环境范围匹配（range）
+
+`range` 字段支持 `起始~结束` 格式，用于一个配置覆盖多个编号环境：
+
+| 用户说法 | 匹配逻辑 | 结果 |
+|---------|---------|------|
+| "去 dev10 查" | 提取前缀 `dev`、编号 `10`，检查 dev 环境 range "1~15"，10 在范围内 | 使用 dev 配置 |
+| "连 test25" | 提取前缀 `test`、编号 `25`，检查 test 环境 range "1~30"，25 在范围内 | 使用 test 配置 |
+| "连 prod" | 精确匹配 prod 环境 | 使用 prod 配置 |
+
+**匹配算法**：
+```
+1. 用户输入的环境名（如 "dev10"）
+2. 先精确匹配环境 key（environments["dev10"]）
+3. 未命中 → 拆分为前缀+编号（"dev" + 10）
+4. 查找有 range 字段的环境，前缀匹配 + 编号在范围内
+5. 命中 → 使用该环境的 host/port/user/password
+```
+
 ### 环境选择规则
 
 | 优先级 | 来源 | 示例 |
 |--------|------|------|
-| 1（最高） | 用户对话中指定 | "连 dev 环境查一下"、"用生产库看看" |
+| 1（最高） | 用户对话中指定 | "连 dev10 环境查一下" |
 | 2 | 配置文件 `default` 字段 | `"default": "local"` |
 
-### 环境关键词映射
-
-用户说的话 → 对应环境名：
-
-| 用户说法 | 环境 |
-|---------|------|
-| "本地"、"local"、"本地环境" | `local` |
-| "开发"、"dev"、"测试环境"、"开发环境" | `dev` |
-| "生产"、"prod"、"线上"、"正式环境" | `prod` |
-
 ### 连接示例
 
 ```bash
-# 用户说"连 dev 环境查一下 order_info"
-# → 读取 environments.dev 的连接信息 + 日志提取的数据库名
+# 用户说"连 dev10 环境查一下 order_info"
+# → range 匹配到 dev 环境的连接信息 + 日志提取的数据库名
 mysql -h dev-db.example.com -P 3306 -u dev_user -p'xxx' 546198574447230976 -e "SELECT ..."
 ```
 

package/bin/index.js

@@ -52,6 +52,9 @@ let targetDir = process.cwd();
 let force     = false;
 let skillFilter = '';  // sync-back --skill <名称>
 let submitIssue = false; // sync-back --submit
+let configType = '';  // config --type <mysql|loki|all>
+let configScope = '';  // config --scope <local|global>
+let configAdd = false; // config --add
 
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
@@ -101,6 +104,23 @@ for (let i = 0; i < args.length; i++) {
     case '--submit':
       submitIssue = true;
       break;
+    case '--type':
+      if (i + 1 >= args.length || args[i + 1].startsWith('-')) {
+        console.error(fmt('red', `错误：${arg} 需要一个值（mysql | loki | all）`));
+        process.exit(1);
+      }
+      configType = args[++i];
+      break;
+    case '--scope':
+      if (i + 1 >= args.length || args[i + 1].startsWith('-')) {
+        console.error(fmt('red', `错误：${arg} 需要一个值（local | global）`));
+        process.exit(1);
+      }
+      configScope = args[++i];
+      break;
+    case '--add':
+      configAdd = true;
+      break;
     case '--help': case '-h':
       printHelp();
       process.exit(0);
@@ -122,7 +142,7 @@ function printHelp() {
   console.log(`  ${fmt('bold', 'update')}           更新已安装的框架文件（跳过用户自定义文件）`);
   console.log(`  ${fmt('bold', 'global')}           全局安装到 ~/.claude / ~/.cursor 等，对所有项目生效`);
   console.log(`  ${fmt('bold', 'sync-back')}        对比本地技能修改，生成 diff 或提交 GitHub Issue`);
-  console.log(`  ${fmt('bold', 'config')}           初始化数据库配置文件（.claude/mysql-config.json）`);
+  console.log(`  ${fmt('bold', 'config')}           初始化环境配置（数据库连接 / Loki 日志 / 全部）`);
   console.log(`  ${fmt('bold', 'mcp')}              MCP 服务器管理（安装/卸载/状态检查）\n`);
   console.log(`无命令时显示交互式主菜单。\n`);
   console.log('选项:');
@@ -131,6 +151,9 @@ function printHelp() {
   console.log('  --force, -f          强制覆盖（init 时覆盖已有文件；update/global 时同时更新保留文件）');
   console.log('  --skill, -s <技能>   sync-back 时只对比指定技能');
   console.log('  --submit             sync-back 时自动创建 GitHub Issue（需要 gh CLI）');
+  console.log('  --type   <类型>      config 时指定配置类型: mysql | loki | all');
+  console.log('  --scope  <范围>      config 时指定范围: local（当前项目） | global（全局 ~/）');
+  console.log('  --add                config 时追加环境（不覆盖已有配置）');
   console.log('  --help,  -h          显示此帮助\n');
   console.log('示例:');
   console.log('  npx ai-engineering-init --tool claude');
@@ -144,6 +167,12 @@ function printHelp() {
   console.log('  npx ai-engineering-init sync-back --tool claude          # 只扫描 Claude');
   console.log('  npx ai-engineering-init sync-back --skill bug-detective  # 只对比指定技能');
   console.log('  npx ai-engineering-init sync-back --skill bug-detective --submit # 提交 Issue');
+  console.log('  npx ai-engineering-init config                         # 交互式选择配置类型');
+  console.log('  npx ai-engineering-init config --type mysql            # 只配置数据库连接');
+  console.log('  npx ai-engineering-init config --type loki             # 只配置 Loki 日志');
+  console.log('  npx ai-engineering-init config --type all              # 配置全部');
+  console.log('  npx ai-engineering-init config --type mysql --scope global  # 全局配置（所有项目共享）');
+  console.log('  npx ai-engineering-init config --type mysql --add          # 追加环境到已有配置');
 }
 
 // ── 工具定义（init 用）────────────────────────────────────────────────────
@@ -1119,162 +1148,479 @@ function runSyncBack(selectedTool, selectedSkill, doSubmit) {
   console.log('');
 }
 
-// ── 数据库配置初始化 ──────────────────────────────────────────────────────
+// ── 环境配置初始化（MySQL / Loki）─────────────────────────────────────────
+
 function runConfig() {
   if (!process.stdin.isTTY) {
     console.error(fmt('red', '错误：config 命令需要交互式终端'));
     process.exit(1);
   }
 
-  const configPath = path.join(targetDir, '.claude', 'mysql-config.json');
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-
   const ask = (question) => new Promise((resolve) => {
     rl.question(question, (answer) => resolve(answer.trim()));
   });
 
-  const ENV_DEFAULTS = {
-    local: { host: '127.0.0.1', user: 'root', desc: '本地开发环境' },
-    dev:   { host: '',          user: '',     desc: '开发测试环境' },
-    test:  { host: '',          user: '',     desc: '测试环境' },
-    prod:  { host: '',          user: '',     desc: '生产环境' },
-  };
-
   (async () => {
     try {
-      // 1. 检测已有配置
-      if (fs.existsSync(configPath)) {
-        console.log(fmt('yellow', `⚠ 配置文件已存在：${configPath}`));
-        const overwrite = await ask(fmt('bold', '是否重新配置？[y/N]: '));
-        if (overwrite.toLowerCase() !== 'y') {
-          console.log('已取消。');
-          rl.close();
-          return;
-        }
-        console.log('');
-      }
+      let type = configType;
+      let scope = configScope;
 
-      // 2. 选择环境
-      console.log(fmt('cyan', '请选择要配置的数据库环境（多选，用逗号分隔）：'));
-      console.log('');
-      console.log(`  ${fmt('bold', '1')}) local  — 本地开发环境`);
-      console.log(`  ${fmt('bold', '2')}) dev    — 开发测试环境`);
-      console.log(`  ${fmt('bold', '3')}) test   — 测试环境`);
-      console.log(`  ${fmt('bold', '4')}) prod   — 生产环境`);
-      console.log('');
-      const envAnswer = await ask(fmt('bold', '请输入选项（如 1,2 或 1-3）: '));
-
-      // 解析选择
-      const envNames = ['local', 'dev', 'test', 'prod'];
-      const selected = new Set();
-      for (const part of envAnswer.split(',')) {
-        const trimmed = part.trim();
-        const rangeMatch = trimmed.match(/^(\d)-(\d)$/);
-        if (rangeMatch) {
-          const start = parseInt(rangeMatch[1], 10);
-          const end = parseInt(rangeMatch[2], 10);
-          for (let n = start; n <= end; n++) {
-            if (n >= 1 && n <= 4) selected.add(envNames[n - 1]);
-          }
-        } else {
-          const n = parseInt(trimmed, 10);
-          if (n >= 1 && n <= 4) selected.add(envNames[n - 1]);
+      // 未指定 --type 时显示交互式菜单
+      if (!type) {
+        console.log(fmt('cyan', '请选择要初始化的配置类型：'));
+        console.log('');
+        console.log(`  ${fmt('bold', '1')}) ${fmt('green', 'MySQL 数据库连接')}   — 配置 mysql-config.json`);
+        console.log(`  ${fmt('bold', '2')}) ${fmt('blue',  'Loki 日志查询')}      — 配置 Grafana Loki Token`);
+        console.log(`  ${fmt('bold', '3')}) ${fmt('yellow','全部配置')}            — 依次配置 MySQL + Loki`);
+        console.log('');
+        const answer = await ask(fmt('bold', '请输入选项 [1-3]: '));
+        switch (answer) {
+          case '1': type = 'mysql'; break;
+          case '2': type = 'loki';  break;
+          case '3': type = 'all';   break;
+          default:
+            console.error(fmt('red', '无效选项，退出。'));
+            rl.close();
+            process.exit(1);
         }
+        console.log('');
       }
 
-      const selectedEnvs = [...selected];
-      if (selectedEnvs.length === 0) {
-        console.error(fmt('red', '未选择任何环境，退出。'));
+      if (!['mysql', 'loki', 'all'].includes(type)) {
+        console.error(fmt('red', `错误：不支持的配置类型 "${type}"，可选：mysql | loki | all`));
         rl.close();
         process.exit(1);
       }
 
-      console.log('');
-      console.log(fmt('green', `已选择环境：${selectedEnvs.join(', ')}`));
-      console.log('');
-
-      // 3. 收集每个环境的配置
-      const environments = {};
-      for (const env of selectedEnvs) {
-        const defaults = ENV_DEFAULTS[env];
-        console.log(fmt('cyan', `── ${env} 环境配置 ──`));
-
-        const host = await ask(`  host [${defaults.host || '无默认'}]: `) || defaults.host;
-        const port = await ask('  port [3306]: ') || '3306';
-        const user = await ask(`  user [${defaults.user || '无默认'}]: `) || defaults.user;
-        const password = await ask('  password: ');
-        const desc = await ask(`  描述 [${defaults.desc}]: `) || defaults.desc;
+      // 未指定 --scope 时询问
+      if (!scope) {
+        console.log(fmt('cyan', '请选择配置范围：'));
+        console.log('');
+        console.log(`  ${fmt('bold', '1')}) ${fmt('green', 'global（全局）')}  — 写入 ~/.claude/，所有项目共享`);
+        console.log(`  ${fmt('bold', '2')}) ${fmt('blue',  'local（本地）')}   — 写入当前项目目录`);
+        console.log('');
+        const scopeAnswer = await ask(fmt('bold', '请输入选项 [1-2，默认 1]: ')) || '1';
+        scope = scopeAnswer === '2' ? 'local' : 'global';
         console.log('');
-
-        if (!host) {
-          console.error(fmt('red', `错误：${env} 环境的 host 不能为空`));
-          rl.close();
-          process.exit(1);
-        }
-        if (!user) {
-          console.error(fmt('red', `错误：${env} 环境的 user 不能为空`));
-          rl.close();
-          process.exit(1);
-        }
-
-        environments[env] = {
-          host,
-          port: parseInt(port, 10),
-          user,
-          password,
-          description: desc,
-        };
       }
 
-      // 4. 选择默认环境
-      let defaultEnv = selectedEnvs[0];
-      if (selectedEnvs.length > 1) {
-        console.log(fmt('cyan', '请选择默认环境：'));
-        selectedEnvs.forEach((env, i) => {
-          console.log(`  ${fmt('bold', String(i + 1))}) ${env}`);
-        });
-        const defaultAnswer = await ask(fmt('bold', `请输入选项 [1-${selectedEnvs.length}]: `));
-        const idx = parseInt(defaultAnswer, 10) - 1;
-        if (idx >= 0 && idx < selectedEnvs.length) {
-          defaultEnv = selectedEnvs[idx];
-        }
-        console.log('');
+      if (!['local', 'global'].includes(scope)) {
+        console.error(fmt('red', `错误：不支持的范围 "${scope}"，可选：local | global`));
+        rl.close();
+        process.exit(1);
       }
 
-      // 5. 写入配置文件
-      const config = { defaultEnv, environments };
-      const claudeDir = path.join(targetDir, '.claude');
-      if (!fs.existsSync(claudeDir)) {
-        fs.mkdirSync(claudeDir, { recursive: true });
+      const isGlobal = scope === 'global';
+      if (isGlobal) {
+        console.log(fmt('magenta', `配置范围：全局（~/.claude/），所有项目共享`));
+      } else {
+        console.log(fmt('magenta', `配置范围：本地（${targetDir}）`));
       }
-      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-      console.log(fmt('green', `✔ 配置已写入：${configPath}`));
-
-      // 6. 确保 .gitignore 包含该文件
-      const gitignorePath = path.join(targetDir, '.gitignore');
-      const ignoreEntry = '.claude/mysql-config.json';
-      let needAppend = true;
-      if (fs.existsSync(gitignorePath)) {
-        const content = fs.readFileSync(gitignorePath, 'utf-8');
-        if (content.split('\n').some(line => line.trim() === ignoreEntry)) {
-          needAppend = false;
-        }
+      console.log('');
+
+      if (type === 'mysql' || type === 'all') {
+        await runMysqlConfig(ask, isGlobal);
       }
-      if (needAppend) {
-        const separator = fs.existsSync(gitignorePath) ? '\n' : '';
-        fs.appendFileSync(gitignorePath, `${separator}${ignoreEntry}\n`, 'utf-8');
-        console.log(fmt('green', `✔ 已添加 ${ignoreEntry} 到 .gitignore`));
+      if (type === 'loki' || type === 'all') {
+        if (type === 'all') console.log('');
+        await runLokiConfig(ask, isGlobal);
       }
 
       console.log('');
-      console.log(fmt('green', '数据库配置初始化完成！'));
-      console.log(`使用 ${fmt('bold', 'mysql-debug')} 技能时将自动读取此配置。`);
+      console.log(fmt('green', fmt('bold', '配置初始化完成！')));
+      if (isGlobal) {
+        console.log(fmt('cyan', '技能会按 全局(~/.claude/) → 本地(.claude/) 顺序查找配置，本地优先。'));
+      }
     } finally {
       rl.close();
     }
   })();
 }
 
+// ── MySQL 数据库配置 ────────────────────────────────────────────────────────
+
+async function runMysqlConfig(ask, isGlobal) {
+  console.log(fmt('blue', fmt('bold', '┌─ MySQL 数据库连接配置 ─┐')));
+  console.log('');
+
+  const configPath = isGlobal
+    ? path.join(HOME_DIR, '.claude', 'mysql-config.json')
+    : path.join(targetDir, '.claude', 'mysql-config.json');
+
+  // 读取已有配置
+  let existingConfig = null;
+  if (fs.existsSync(configPath)) {
+    try { existingConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8')); } catch { /* ignore */ }
+  }
+
+  // --add 模式
+  if (configAdd && existingConfig && existingConfig.environments) {
+    console.log(fmt('cyan', '当前已配置的环境：'));
+    for (const [key, env] of Object.entries(existingConfig.environments)) {
+      const rangeStr = env.range ? fmt('magenta', ` (range: ${env.range})`) : '';
+      console.log(`  ${fmt('bold', key)} — ${env._desc || key}${rangeStr}  host=${env.host}`);
+    }
+    console.log('');
+    console.log(fmt('green', '将追加新环境到已有配置。'));
+    console.log('');
+  } else if (existingConfig && !configAdd) {
+    console.log(fmt('yellow', `⚠ 配置文件已存在：${configPath}`));
+    const overwrite = await ask(fmt('bold', '输入 add 追加环境，y 重建，N 跳过 [add/y/N]: '));
+    if (overwrite.toLowerCase() === 'add') {
+      // 进入追加模式
+    } else if (overwrite.toLowerCase() !== 'y') {
+      console.log('已跳过 MySQL 配置。');
+      return;
+    } else {
+      existingConfig = null;
+    }
+    console.log('');
+  }
+
+  // 自定义环境名输入
+  console.log(fmt('cyan', '请输入要配置的环境（自定义名称，多个用逗号分隔）：'));
+  console.log(fmt('yellow', '  示例：local, dev, test, prod 或自定义名称'));
+  console.log('');
+  const envAnswer = await ask(fmt('bold', '环境名称: '));
+  const envNames = envAnswer.split(',').map(s => s.trim()).filter(Boolean);
+
+  if (envNames.length === 0) {
+    console.error(fmt('red', '未输入任何环境名，跳过 MySQL 配置。'));
+    return;
+  }
+  console.log('');
+
+  // 收集每个环境的配置
+  const newEnvironments = {};
+  for (const env of envNames) {
+    if (existingConfig && existingConfig.environments && existingConfig.environments[env]) {
+      console.log(fmt('yellow', `  ${env} 已存在，跳过。使用 y 模式可重建。`));
+      continue;
+    }
+
+    const isLocal = env === 'local';
+    console.log(fmt('cyan', `── ${env} 环境配置 ──`));
+
+    const host = await ask(`  host [${isLocal ? '127.0.0.1' : '无默认'}]: `) || (isLocal ? '127.0.0.1' : '');
+    if (!host) { console.error(fmt('red', `  host 不能为空，跳过。`)); continue; }
+    const port = await ask('  port [3306]: ') || '3306';
+    const user = await ask(`  user [${isLocal ? 'root' : '无默认'}]: `) || (isLocal ? 'root' : '');
+    if (!user) { console.error(fmt('red', `  user 不能为空，跳过。`)); continue; }
+    const password = await ask('  password: ');
+    const desc = await ask(`  描述 [${env}环境]: `) || `${env}环境`;
+    const rangeInput = await ask(`  覆盖范围（如 ${fmt('bold', '1~15')} 表示 ${env}1→${env}15，留空=无范围）: `);
+    console.log('');
+
+    newEnvironments[env] = { host, port: parseInt(port, 10), user, password, _desc: desc };
+    if (rangeInput) newEnvironments[env].range = rangeInput;
+  }
+
+  if (Object.keys(newEnvironments).length === 0 && !existingConfig) {
+    console.error(fmt('red', '未成功配置任何环境。'));
+    return;
+  }
+
+  // 合并配置
+  const allEnvironments = {
+    ...(existingConfig && existingConfig.environments ? existingConfig.environments : {}),
+    ...newEnvironments,
+  };
+
+  // 选择默认环境
+  const allEnvKeys = Object.keys(allEnvironments);
+  let defaultEnv = (existingConfig && existingConfig.default) || allEnvKeys[0];
+  if (Object.keys(newEnvironments).length > 0 && allEnvKeys.length > 1) {
+    console.log(fmt('cyan', '请选择默认环境：'));
+    allEnvKeys.forEach((env, i) => {
+      const marker = env === defaultEnv ? fmt('green', ' (当前)') : '';
+      console.log(`  ${fmt('bold', String(i + 1))}) ${env}${marker}`);
+    });
+    const defaultAnswer = await ask(fmt('bold', `请输入选项 [1-${allEnvKeys.length}，回车保持当前]: `));
+    if (defaultAnswer) {
+      const idx = parseInt(defaultAnswer, 10) - 1;
+      if (idx >= 0 && idx < allEnvKeys.length) defaultEnv = allEnvKeys[idx];
+    }
+    console.log('');
+  }
+
+  const config = {
+    environments: allEnvironments,
+    default: defaultEnv,
+    _comment: '环境支持 range 字段（如 "1~15"），用户说"dev10"时自动匹配。查找顺序：本地 .claude/ > 全局 ~/.claude/',
+  };
+
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  console.log(`  ${fmt('green', '✔')} 已写入：${configPath}`);
+
+  if (!isGlobal) ensureGitignore(['mysql-config.json']);
+
+  console.log('');
+  console.log(fmt('green', 'MySQL 数据库配置完成！'));
+  for (const [key, env] of Object.entries(newEnvironments)) {
+    if (env.range) {
+      console.log(fmt('cyan', `  ${key} 覆盖 ${key}${env.range.replace('~', '→')}，说"${key}10"将自动匹配`));
+    }
+  }
+}
+
+// ── Loki 日志查询配置 ──────────────────────────────────────────────────────
+
+async function runLokiConfig(ask, isGlobal) {
+  console.log(fmt('blue', fmt('bold', '┌─ Loki 日志查询配置 ─┐')));
+  console.log('');
+
+  const configPath = isGlobal
+    ? path.join(HOME_DIR, '.claude', 'loki-config.json')
+    : getLokiConfigPath();
+
+  if (!configPath) {
+    console.log(fmt('yellow', '⚠ 未检测到配置目录。请先运行 init 安装框架。'));
+    return;
+  }
+
+  let existingConfig = null;
+  if (fs.existsSync(configPath)) {
+    try { existingConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8')); } catch { /* ignore */ }
+  }
+
+  if (existingConfig && existingConfig.environments) {
+    const envs = existingConfig.environments;
+    const envList = Object.keys(envs);
+    console.log(fmt('cyan', '当前已配置的 Loki 环境：'));
+    console.log('');
+    for (const key of envList) {
+      const env = envs[key];
+      const hasToken = env.token && env.token.length > 0;
+      const status = hasToken ? fmt('green', '✔ Token') : fmt('red', '✗ 缺Token');
+      const rangeStr = env.range ? fmt('magenta', ` (range: ${env.range})`) : '';
+      console.log(`  ${fmt('bold', key)} — ${env.name || key}  ${status}${rangeStr}`);
+    }
+    console.log('');
+
+    if (configAdd) {
+      console.log(fmt('green', '将追加新环境到已有配置。'));
+    } else {
+      const missingTokenEnvs = envList.filter(k => !envs[k].token);
+      const action = await ask(fmt('bold', '输入 token 补充Token，add 追加环境，N 跳过 [token/add/N]: ')) || 'token';
+      if (action.toLowerCase() === 'token') {
+        await updateLokiTokens(ask, existingConfig, configPath, isGlobal);
+        return;
+      } else if (action.toLowerCase() !== 'add') {
+        console.log('已跳过 Loki 配置。');
+        return;
+      }
+    }
+    console.log('');
+
+    // 追加环境
+    await addLokiEnvironments(ask, existingConfig, configPath, isGlobal);
+  } else {
+    await createLokiConfig(ask, configPath, isGlobal);
+  }
+}
+
+async function updateLokiTokens(ask, config, configPath, isGlobal) {
+  console.log('');
+  console.log(fmt('cyan', fmt('bold', 'Grafana Token 获取：')));
+  console.log(`  Grafana → Administration → Service accounts → Add（Viewer）→ Add token`);
+  console.log('');
+
+  const envs = config.environments;
+  for (const key of Object.keys(envs)) {
+    const env = envs[key];
+    const hasToken = env.token && env.token.length > 0;
+    if (hasToken) {
+      const update = await ask(`  ${fmt('bold', key)} 已有 Token，更新？[y/N]: `);
+      if (update.toLowerCase() !== 'y') continue;
+    }
+    if (env.url) console.log(`  URL: ${fmt('bold', env.url)}`);
+    const token = await ask(`  输入 ${key} 的 Token: `);
+    if (token) {
+      envs[key].token = token;
+      console.log(`  ${fmt('green', '✔')} 已设置`);
+    }
+    console.log('');
+  }
+
+  writeLokiConfig(config, configPath, isGlobal);
+}
+
+async function addLokiEnvironments(ask, config, configPath, isGlobal) {
+  printLokiTokenGuide();
+  const countAnswer = await ask(fmt('bold', '要追加几个环境？[1]: ')) || '1';
+  const count = Math.max(1, Math.min(10, parseInt(countAnswer, 10) || 1));
+  console.log('');
+
+  for (let i = 0; i < count; i++) {
+    const envData = await collectLokiEnvInput(ask, i + 1, count);
+    if (!envData) continue;
+    config.environments[envData.key] = envData.value;
+  }
+
+  writeLokiConfig(config, configPath, isGlobal);
+}
+
+async function createLokiConfig(ask, configPath, isGlobal) {
+  console.log(fmt('cyan', '将创建新的 Loki 日志查询配置。'));
+  console.log('');
+  printLokiTokenGuide();
+  const countAnswer = await ask(fmt('bold', '要配置几个 Grafana 环境？[1]: ')) || '1';
+  const count = Math.max(1, Math.min(10, parseInt(countAnswer, 10) || 1));
+  console.log('');
+
+  const environments = {};
+  let activeEnv = '';
+
+  for (let i = 0; i < count; i++) {
+    const envData = await collectLokiEnvInput(ask, i + 1, count);
+    if (!envData) continue;
+    environments[envData.key] = envData.value;
+    if (!activeEnv) activeEnv = envData.key;
+  }
+
+  if (Object.keys(environments).length === 0) {
+    console.error(fmt('red', '未配置任何环境。'));
+    return;
+  }
+
+  const envKeys = Object.keys(environments);
+  if (envKeys.length > 1) {
+    console.log(fmt('cyan', '请选择默认活跃环境：'));
+    envKeys.forEach((env, i) => console.log(`  ${fmt('bold', String(i + 1))}) ${env}`));
+    const activeAnswer = await ask(fmt('bold', `请输入选项 [1-${envKeys.length}]: `));
+    const idx = parseInt(activeAnswer, 10) - 1;
+    if (idx >= 0 && idx < envKeys.length) activeEnv = envKeys[idx];
+    console.log('');
+  }
+
+  const config = {
+    _comment: 'Loki 多环境配置。环境支持 range 字段。查找顺序：本地 > 全局 ~/.claude/',
+    _setup: 'Token：Grafana → Administration → Service accounts → Add（Viewer）→ Add token',
+    active: activeEnv,
+    environments,
+  };
+
+  writeLokiConfig(config, configPath, isGlobal);
+}
+
+function printLokiTokenGuide() {
+  console.log(fmt('cyan', fmt('bold', 'Grafana Token 获取：')));
+  console.log(`  Grafana → Administration → Service accounts → Add（Viewer）→ Add token`);
+  console.log('');
+}
+
+async function collectLokiEnvInput(ask, index, total) {
+  console.log(fmt('cyan', `── 环境 ${index}/${total} ──`));
+  const envKey = await ask(`  环境标识（如 monitor-dev、test13）: `);
+  if (!envKey) { console.log(fmt('yellow', '  跳过')); return null; }
+  const name = await ask(`  环境名称（如 "开发环境"）: `) || envKey;
+  const url = await ask(`  Grafana URL: `);
+  const token = await ask(`  Token（可留空稍后配）: `);
+  const aliasStr = await ask(`  别名（逗号分隔）[${envKey}]: `) || envKey;
+  const aliases = aliasStr.split(',').map(s => s.trim()).filter(Boolean);
+  const rangeInput = await ask(`  项目覆盖范围（如 ${fmt('bold', 'dev1~15')} 表示 dev01→dev15，留空=无范围）: `);
+  console.log('');
+
+  const value = { name, url, token: token || '', aliases };
+  if (rangeInput) {
+    value.range = rangeInput;
+    value.projects = expandRange(rangeInput);
+    if (value.projects.length > 0) {
+      console.log(fmt('cyan', `  已展开 ${value.projects.length} 个项目：${value.projects.slice(0, 5).join(', ')}${value.projects.length > 5 ? '...' : ''}`));
+      console.log('');
+    }
+  } else {
+    value.projects = [];
+  }
+
+  return { key: envKey, value };
+}
+
+function writeLokiConfig(config, configPath, isGlobal) {
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  console.log(`  ${fmt('green', '✔')} 已写入：${configPath}`);
+  if (!isGlobal) ensureGitignore(['loki-config.json', 'environments.json']);
+  console.log('');
+  console.log(fmt('green', 'Loki 日志查询配置完成！'));
+}
+
+// ── Config 工具函数 ─────────────────────────────────────────────────────────
+
+function getLokiConfigPath() {
+  const lokiJsonClaude = path.join(targetDir, '.claude', 'loki-config.json');
+  if (fs.existsSync(lokiJsonClaude)) return lokiJsonClaude;
+  const envJsonClaude = path.join(targetDir, '.claude', 'skills', 'loki-log-query', 'environments.json');
+  if (fs.existsSync(envJsonClaude)) return envJsonClaude;
+  const envJsonCursor = path.join(targetDir, '.cursor', 'skills', 'loki-log-query', 'environments.json');
+  if (fs.existsSync(envJsonCursor)) return envJsonCursor;
+  if (fs.existsSync(path.join(targetDir, '.claude'))) return lokiJsonClaude;
+  if (fs.existsSync(path.join(targetDir, '.cursor'))) return path.join(targetDir, '.cursor', 'loki-config.json');
+  return null;
+}
+
+/** 展开范围字符串为项目名列表，如 "dev1~15" → ["dev01","dev02",...,"dev15"] */
+function expandRange(rangeStr) {
+  const match = rangeStr.match(/^([a-zA-Z-]*)(\d+)\s*[~～]\s*(\d+)$/);
+  if (!match) return [];
+  const prefix = match[1];
+  const start = parseInt(match[2], 10);
+  const end = parseInt(match[3], 10);
+  const maxDigits = Math.max(String(start).length, String(end).length, 2);
+  const result = [];
+  for (let i = start; i <= end; i++) {
+    result.push(prefix + String(i).padStart(maxDigits, '0'));
+  }
+  return result;
+}
+
+function parseSelection(answer, names) {
+  const selected = new Set();
+  for (const part of answer.split(',')) {
+    const trimmed = part.trim();
+    const rangeMatch = trimmed.match(/^(\d)-(\d)$/);
+    if (rangeMatch) {
+      const start = parseInt(rangeMatch[1], 10);
+      const end = parseInt(rangeMatch[2], 10);
+      for (let n = start; n <= end; n++) {
+        if (n >= 1 && n <= names.length) selected.add(names[n - 1]);
+      }
+    } else {
+      const n = parseInt(trimmed, 10);
+      if (n >= 1 && n <= names.length) selected.add(names[n - 1]);
+    }
+  }
+  return [...selected];
+}
+
+function ensureGitignore(patterns) {
+  const gitignorePath = path.join(targetDir, '.gitignore');
+  let content = '';
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, 'utf-8');
+  }
+  const lines = content.split('\n').map(l => l.trim());
+  const toAdd = [];
+  for (const pattern of patterns) {
+    const alreadyIgnored = lines.some(line =>
+      line.endsWith(pattern) || line.endsWith(`/${pattern}`) || line === `**/${pattern}`
+    );
+    if (!alreadyIgnored) {
+      toAdd.push(`# 敏感配置 - ${pattern}`);
+      toAdd.push(`**/${pattern}`);
+    }
+  }
+  if (toAdd.length > 0) {
+    const separator = content.endsWith('\n') || content === '' ? '' : '\n';
+    fs.appendFileSync(gitignorePath, `${separator}${toAdd.join('\n')}\n`, 'utf-8');
+    console.log(`  ${fmt('green', '✔')} 已更新 .gitignore`);
+  }
+}
+
 // ── MCP 服务器管理 ──────────────────────────────────────────────────────────
 
 const MCP_REGISTRY = [
@@ -1765,7 +2111,7 @@ function showMainMenu() {
   console.log(`  ${fmt('bold', '2')}) ${fmt('cyan',    '更新')}           — 更新已安装的框架文件`);
   console.log(`  ${fmt('bold', '3')}) ${fmt('yellow',  '全局安装')}       — 安装到 ~/.claude 等，对所有项目生效`);
   console.log(`  ${fmt('bold', '4')}) ${fmt('magenta', '技能同步反馈')}   — 对比本地技能修改，生成 diff`);
-  console.log(`  ${fmt('bold', '5')}) ${fmt('blue',    '数据库配置')}     — 初始化 mysql-config.json（数据库连接信息）`);
+  console.log(`  ${fmt('bold', '5')}) ${fmt('blue',    '环境配置')}       — 初始化数据库连接 / Loki 日志查询配置`);
   console.log(`  ${fmt('bold', '6')}) ${fmt('green',   'MCP 管理')}       — MCP 服务器安装/卸载/状态检查`);
   console.log('');
   rl.question(fmt('bold', '请输入选项 [1-6]: '), (answer) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-engineering-init",
-  "version": "1.15.0",
+  "version": "1.16.1",
   "description": "AI 工程化配置初始化工具 — 一键为 Claude Code、OpenAI Codex 等 AI 工具初始化 Skills 和项目规范",
   "keywords": [
     "claude-code",