ai-engineering-init 1.16.3 → 1.17.0

package/bin/index.js

@@ -55,6 +55,7 @@ let submitIssue = false; // sync-back --submit
 let configType = '';  // config --type <mysql|loki|all>
 let configScope = '';  // config --scope <local|global>
 let configAdd = false; // config --add
+let configFrom = '';   // config --from <file.md>
 
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
@@ -121,6 +122,13 @@ for (let i = 0; i < args.length; i++) {
     case '--add':
       configAdd = true;
       break;
+    case '--from':
+      if (i + 1 >= args.length || args[i + 1].startsWith('-')) {
+        console.error(fmt('red', `错误：${arg} 需要一个文件路径`));
+        process.exit(1);
+      }
+      configFrom = path.resolve(args[++i]);
+      break;
     case '--help': case '-h':
       printHelp();
       process.exit(0);
@@ -154,6 +162,7 @@ function printHelp() {
   console.log('  --type   <类型>      config 时指定配置类型: mysql | loki | all');
   console.log('  --scope  <范围>      config 时指定范围: local（当前项目） | global（全局 ~/）');
   console.log('  --add                config 时追加环境（不覆盖已有配置）');
+  console.log('  --from   <文件>      config 时从 Markdown 文件解析配置（跳过交互）');
   console.log('  --help,  -h          显示此帮助\n');
   console.log('示例:');
   console.log('  npx ai-engineering-init --tool claude');
@@ -173,6 +182,7 @@ function printHelp() {
   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          # 追加环境到已有配置');
+  console.log('  npx ai-engineering-init config --from env-config.md --scope global  # 从 MD 文件一键初始化');
 }
 
 // ── 工具定义（init 用）────────────────────────────────────────────────────
@@ -1151,8 +1161,14 @@ function runSyncBack(selectedTool, selectedSkill, doSubmit) {
 // ── 环境配置初始化（MySQL / Loki）─────────────────────────────────────────
 
 function runConfig() {
+  // --from 模式：从 MD 文件解析配置（非交互式）
+  if (configFrom) {
+    runConfigFromFile(configFrom, configScope || 'global');
+    return;
+  }
+
   if (!process.stdin.isTTY) {
-    console.error(fmt('red', '错误：config 命令需要交互式终端'));
+    console.error(fmt('red', '错误：config 命令需要交互式终端（或使用 --from <file> 跳过交互）'));
     process.exit(1);
   }
 
@@ -1571,6 +1587,224 @@ function writeLokiConfig(config, configPath, isGlobal) {
   console.log(fmt('green', 'Loki 日志查询配置完成！'));
 }
 
+// ── 从 Markdown 文件解析配置（非交互式）──────────────────────────────────────
+
+function runConfigFromFile(filePath, scope) {
+  if (!fs.existsSync(filePath)) {
+    console.error(fmt('red', `错误：文件不存在 "${filePath}"`));
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const isGlobal = scope === 'global';
+
+  console.log(fmt('blue', fmt('bold', `从 Markdown 文件解析配置：${filePath}`)));
+  console.log(fmt('magenta', `配置范围：${isGlobal ? '全局（~/.claude/）' : '本地（当前项目）'}`));
+  console.log('');
+
+  // 解析 MySQL 表格
+  const mysqlConfig = parseMysqlFromMd(content);
+  if (mysqlConfig) {
+    const mysqlPath = isGlobal
+      ? path.join(HOME_DIR, '.claude', 'mysql-config.json')
+      : path.join(targetDir, '.claude', 'mysql-config.json');
+
+    const configJson = JSON.stringify(mysqlConfig, null, 2) + '\n';
+    const dir = path.dirname(mysqlPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(mysqlPath, configJson, 'utf-8');
+    console.log(`  ${fmt('green', '✔')} MySQL 配置（${Object.keys(mysqlConfig.environments).length} 个环境）→ ${mysqlPath}`);
+
+    // 全局同步到 cursor
+    if (isGlobal && fs.existsSync(path.join(HOME_DIR, '.cursor'))) {
+      const cursorPath = path.join(HOME_DIR, '.cursor', 'mysql-config.json');
+      fs.writeFileSync(cursorPath, configJson, 'utf-8');
+      console.log(`  ${fmt('green', '✔')} 已同步 → ${cursorPath}`);
+    }
+  }
+
+  // 解析 Loki 表格
+  const lokiConfig = parseLokiFromMd(content);
+  if (lokiConfig) {
+    const lokiPath = isGlobal
+      ? path.join(HOME_DIR, '.claude', 'loki-config.json')
+      : path.join(targetDir, '.claude', 'loki-config.json');
+
+    const configJson = JSON.stringify(lokiConfig, null, 2) + '\n';
+    const dir = path.dirname(lokiPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(lokiPath, configJson, 'utf-8');
+    console.log(`  ${fmt('green', '✔')} Loki 配置（${Object.keys(lokiConfig.environments).length} 个环境）→ ${lokiPath}`);
+
+    if (isGlobal && fs.existsSync(path.join(HOME_DIR, '.cursor'))) {
+      const cursorPath = path.join(HOME_DIR, '.cursor', 'loki-config.json');
+      fs.writeFileSync(cursorPath, configJson, 'utf-8');
+      console.log(`  ${fmt('green', '✔')} 已同步 → ${cursorPath}`);
+    }
+  }
+
+  if (!mysqlConfig && !lokiConfig) {
+    console.error(fmt('red', '未在文件中找到 MySQL 或 Loki 配置表格。'));
+    console.log('');
+    console.log('期望格式（MySQL）：');
+    console.log('  | 环境 | host | port | user | password | range | 描述 |');
+    console.log('');
+    console.log('期望格式（Loki）：');
+    console.log('  | 环境 | 名称 | URL | Token | 别名 | range |');
+    process.exit(1);
+  }
+
+  if (!isGlobal) ensureGitignore(['mysql-config.json', 'loki-config.json']);
+
+  console.log('');
+  console.log(fmt('green', fmt('bold', '配置初始化完成！')));
+  if (isGlobal) {
+    console.log(fmt('cyan', '技能按 本地(.claude/) → 全局(~/.claude/) 顺序查找，本地优先。'));
+  }
+}
+
+/** 从 Markdown 内容中解析 MySQL 配置表格 */
+function parseMysqlFromMd(content) {
+  // 找到 "MySQL" 标题后的表格
+  const mysqlSection = extractSection(content, /mysql|数据库/i);
+  if (!mysqlSection) return null;
+
+  const rows = parseTable(mysqlSection);
+  if (rows.length === 0) return null;
+
+  const environments = {};
+  for (const row of rows) {
+    const env = row['环境'] || row['env'] || '';
+    if (!env) continue;
+
+    const host = row['host'] || '';
+    const port = parseInt(row['port'] || '3306', 10);
+    const user = row['user'] || '';
+    const password = row['password'] || '';
+    const range = row['range'] || '';
+    const desc = row['描述'] || row['desc'] || `${env}环境`;
+
+    if (!host || host.startsWith('YOUR_')) continue; // 跳过未填写的占位符
+
+    environments[env] = { host, port, user, password, _desc: desc };
+    if (range) environments[env].range = range;
+  }
+
+  if (Object.keys(environments).length === 0) return null;
+
+  // 提取默认环境
+  const defaultMatch = mysqlSection.match(/默认环境[:：]\s*(\S+)/);
+  const defaultEnv = defaultMatch ? defaultMatch[1] : Object.keys(environments)[0];
+
+  return {
+    environments,
+    default: defaultEnv,
+    _comment: '从 Markdown 文件解析生成。支持 range 字段，查找顺序：本地 > 全局 ~/.claude/',
+  };
+}
+
+/** 从 Markdown 内容中解析 Loki 配置表格 */
+function parseLokiFromMd(content) {
+  const lokiSection = extractSection(content, /loki|日志/i);
+  if (!lokiSection) return null;
+
+  const rows = parseTable(lokiSection);
+  if (rows.length === 0) return null;
+
+  const environments = {};
+  for (const row of rows) {
+    const env = row['环境'] || row['env'] || '';
+    if (!env) continue;
+
+    const name = row['名称'] || row['name'] || env;
+    const url = row['url'] || row['URL'] || '';
+    const token = row['token'] || row['Token'] || '';
+    const aliasStr = row['别名'] || row['aliases'] || env;
+    const aliases = aliasStr.split(',').map(s => s.trim()).filter(Boolean);
+    const rangeStr = row['range'] || '';
+
+    if (!url || url.startsWith('YOUR_')) continue;
+
+    const envData = { name, url, token: token.startsWith('YOUR_') ? '' : token, aliases };
+    if (rangeStr) {
+      envData.range = rangeStr;
+      envData.projects = expandRange(rangeStr);
+    } else {
+      envData.projects = [];
+    }
+
+    environments[env] = envData;
+  }
+
+  if (Object.keys(environments).length === 0) return null;
+
+  const defaultMatch = lokiSection.match(/默认环境[:：]\s*(\S+)/);
+  const activeEnv = defaultMatch ? defaultMatch[1] : Object.keys(environments)[0];
+
+  return {
+    _comment: '从 Markdown 文件解析生成。支持 range 字段，查找顺序：本地 > 全局 ~/.claude/',
+    _setup: 'Token：Grafana → Administration → Service accounts → Add（Viewer）→ Add token',
+    active: activeEnv,
+    environments,
+  };
+}
+
+/** 从 Markdown 中按标题提取段落 */
+function extractSection(content, titlePattern) {
+  const lines = content.split('\n');
+  let start = -1;
+  let end = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.match(/^#+\s/) && titlePattern.test(line)) {
+      start = i;
+      const level = line.match(/^(#+)/)[1].length;
+      // 找到同级或更高级标题作为结束
+      for (let j = i + 1; j < lines.length; j++) {
+        const nextMatch = lines[j].match(/^(#+)\s/);
+        if (nextMatch && nextMatch[1].length <= level) {
+          end = j;
+          break;
+        }
+      }
+      break;
+    }
+  }
+  if (start === -1) return null;
+  return lines.slice(start, end).join('\n');
+}
+
+/** 解析 Markdown 表格为对象数组 */
+function parseTable(text) {
+  const lines = text.split('\n');
+  let headerLine = -1;
+
+  // 找到表头行（含 | 的行，下一行是分隔线 |---|）
+  for (let i = 0; i < lines.length - 1; i++) {
+    if (lines[i].includes('|') && lines[i + 1] && lines[i + 1].match(/^\|[\s-:|]+\|$/)) {
+      headerLine = i;
+      break;
+    }
+  }
+  if (headerLine === -1) return [];
+
+  const parseRow = (line) => line.split('|').map(s => s.trim()).filter(Boolean);
+  const headers = parseRow(lines[headerLine]);
+  const rows = [];
+
+  for (let i = headerLine + 2; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.includes('|')) break;
+    const cells = parseRow(line);
+    if (cells.length === 0) break;
+    const row = {};
+    headers.forEach((h, idx) => { row[h] = cells[idx] || ''; });
+    rows.push(row);
+  }
+
+  return rows;
+}
+
 // ── Config 工具函数 ─────────────────────────────────────────────────────────
 
 function getLokiConfigPath() {

package/package.json

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

package/.claude/skills/leniu-marketing-price-rule-customizer/SKILL.md

@@ -1,301 +0,0 @@
----
-name: leniu-marketing-price-rule-customizer
-description: |
-  leniu-tengyun-core 项目营销计费（price）规则定制指南。当需要定制营销计费规则时使用，支持新增规则类型、重写规则逻辑、扩展 DTO 字段。
-
-  触发场景：
-  - 新增营销计费规则类型（折扣、满减、限额、补贴等）
-  - 重写现有计费规则逻辑（@Primary 模式）
-  - 扩展规则 DTO 字段（向后兼容）
-  - 定制规则计算行为（handle 方法实现）
-  - 注册规则枚举（RulePriceEnum）
-
-  适用项目：
-  - leniu-tengyun-core：/Users/xujiajun/Developer/gongsi_proj/leniu-api/leniu-tengyun-core
-  - leniu-yunshitang：/Users/xujiajun/Developer/gongsi_proj/leniu-api/leniu-tengyun/leniu-yunshitang
-
-  触发词：营销计费、计价规则、RulePriceHandler、RulePriceEnum、折扣规则、满减规则、限额规则、补贴规则
----
-
-# leniu-tengyun-core 营销计费规则定制
-
-## 概述
-
-leniu-tengyun-core 项目的营销计费（price）规则功能采用扩展点设计，支持灵活的规则定制。
-
-营销计费规则是营销系统的核心组件，负责计算订单的优惠金额、限制消费行为、提供补贴等功能。
-
-## 何时使用此 Skill
-
-- 需要新增一个计价规则类型
-- 需要修改现有规则的计算逻辑
-- 需要为规则添加新的配置字段
-- 需要针对特定项目定制规则行为
-- 参考现有规则实现新的定制需求
-
-## 规则定制工作流
-
-### 步骤1：确定定制模式
-
-根据需求选择合适的定制模式：
-
-**模式A：新增规则**
-- 适用场景：创建全新的规则类型
-- 需要创建：DTO、扩展接口、默认实现
-
-**模式B：重写规则（@Primary）**
-- 适用场景：完全替换现有规则行为
-- 需要创建：定制实现类（使用@Primary注解）
-- 可选：扩展DTO字段
-
-**模式C：重写规则（Ordered）**
-- 适用场景：多个实现共存
-- 需要创建：定制实现类（实现Ordered接口）
-
-### 步骤2：理解规则结构
-
-了解：
-- 规则接口层次（RulePriceHandler → Extension → Implementation）
-- 规则DTO结构
-- 规则计算入参（RulePriceResultOrderDTO、MarketRuleVO、orderResults）
-- 规则计算流程
-- 常用工具类（MarketUtil、MarketRuleRangeService）
-
-### 步骤3：参考实际案例
-
-查看实际案例，了解如何实现具体的定制需求：
-- **案例1**：支持自定义场景类型选择（@Primary + DTO扩展）
-- **案例2**：移除订单类型过滤（直接修改）
-
-### 步骤4：实现规则定制
-
-#### 新增规则的实现步骤
-
-1. **创建规则DTO**
-   - 位置：`net.xnzn.core.marketing.v2.rule.price.handler.[ruletype].dto`
-   - 包含规则配置字段
-   - 实现 `toString()` 方法返回可读描述
-
-2. **创建扩展接口**
-   - 位置：`net.xnzn.core.marketing.v2.rule.price.handler.[ruletype].extension`
-   - 继承 `RulePriceHandler`
-   - 实现 `getRuleType()` 和 `checkRuleInfo()` 方法
-
-3. **创建默认实现**
-   - 位置：`net.xnzn.core.marketing.v2.rule.price.handler.[ruletype].extension.impl`
-   - 实现扩展接口
-   - 添加 `@Service` 注解
-   - 实现 `handle()` 方法
-
-4. **注册规则枚举**
-   - 在 `RulePriceEnum` 中添加新的规则类型
-
-#### 重写规则的实现步骤（@Primary模式）
-
-1. **（可选）扩展DTO字段**
-   - 在定制项目中覆盖核心DTO类
-   - 添加新字段并保持向后兼容
-
-2. **创建定制实现**
-   - 位置：定制项目包（如 `net.xnzn.yunshitang.marketing.handler`）
-   - 继承默认实现类（可选，用于复用逻辑）
-   - 实现扩展接口
-   - 添加 `@Service` 和 `@Primary` 注解
-   - 重写 `handle()` 方法
-
-3. **实现定制逻辑**
-   - 解析规则配置（包含新字段）
-   - 实现自定义计算逻辑
-   - 更新订单优惠金额或抛出限制异常
-
-### 步骤5：测试规则
-
-1. 测试向后兼容性（新字段为null的场景）
-2. 测试新功能（新字段有值的场景）
-3. 测试边界条件
-4. 测试与其他规则的组合使用
-
-## 代码模板
-
-### 新增规则模板
-
-```java
-// 1. DTO
-@Data
-@ApiModel("计价规则详情-[规则名称]")
-public class [RuleType]DTO {
-    @ApiModelProperty("[字段说明]")
-    private [Type] fieldName;
-
-    @Override
-    public String toString() {
-        return "字段：" + fieldName;
-    }
-}
-
-// 2. 扩展接口
-public interface [RuleType]HandlerExtension extends RulePriceHandler {
-    @Override
-    default Integer getRuleType() {
-        return RulePriceEnum.[RULE_TYPE_ENUM].getKey();
-    }
-
-    @Override
-    default String checkRuleInfo(String ruleInfo) {
-        [RuleType]DTO rule = JSON.parseObject(ruleInfo, [RuleType]DTO.class);
-        return rule.toString();
-    }
-}
-
-// 3. 默认实现
-@Slf4j
-@Service
-public class Default[RuleType]HandlerImpl implements [RuleType]HandlerExtension {
-
-    @Autowired
-    private MarketRuleRangeService rangeService;
-
-    @Override
-    public void handle(RulePriceResultOrderDTO order, MarketRuleVO rule,
-                      List<RulePriceResultOrderDTO> orderResults) {
-        // 1. 解析规则配置
-        [RuleType]DTO ruleInfo = JSON.parseObject(rule.getRuleInfo(), [RuleType]DTO.class);
-
-        // 2. 查询规则适用范围
-        List<MarketRuleRange> rangeList = rangeService.listRuleRangeLatest(rule.getRuleId());
-
-        // 3. 实现规则计算逻辑
-        // ...
-
-        // 4. 更新订单优惠金额或抛出异常
-        order.setDiscountsAmount(order.getDiscountsAmount().add(discountAmount));
-    }
-}
-```
-
-### 重写规则模板（@Primary）
-
-```java
-@Slf4j
-@Service
-@Primary  // 标记为主要实现
-public class Custom[RuleType]HandlerImpl extends Default[RuleType]HandlerImpl
-        implements [RuleType]HandlerExtension {
-
-    @Autowired
-    private MarketRuleRangeService rangeService;
-
-    @Override
-    public void handle(RulePriceResultOrderDTO order, MarketRuleVO rule,
-                      List<RulePriceResultOrderDTO> orderResults) {
-        // 解析规则配置（可能包含扩展字段）
-        [RuleType]DTO ruleInfo = JSON.parseObject(rule.getRuleInfo(), [RuleType]DTO.class);
-
-        // 实现定制逻辑
-        // 可以调用父类方法：super.handle(order, rule, orderResults);
-        // 或完全自定义实现
-    }
-}
-```
-
-## 常见规则类型
-
-### 优惠类规则
-- 折扣规则：`PriceDiscountHandlerExtension`
-- 菜品折扣：`PriceDishDiscountHandlerExtension`
-- 商品折扣：`PriceGoodsDiscountHandlerExtension`
-- 满减规则：`PriceReductionFixedHandlerExtension`
-
-### 限制类规则
-- 限额-单次金额：`PriceLimitMaxAmountHandlerExtension`
-- 限额-累计次数：`PriceLimitMaxCountHandlerExtension`
-- 限额-累计金额：`PriceLimitSumAmountHandlerExtension`
-
-### 补贴类规则
-- 固定补贴：`PriceSubsidyFixedHandlerExtension`
-- 累计赠送：`PriceSumGiveHandlerExtension`
-
-## 最佳实践
-
-### 包名规范
-- 覆盖核心类：使用核心工程的包名（`net.xnzn.core.marketing.v2.rule.price.handler.[ruletype]`）
-- 定制实现：使用项目特定包名（如 `net.xnzn.yunshitang.marketing.handler`）
-
-### 类名规范
-- 扩展接口：`[RuleType]HandlerExtension`
-- 默认实现：`Default[RuleType]HandlerImpl`
-- 定制实现：`Custom[RuleType]HandlerImpl` 或描述性名称
-
-### 注解使用
-- 所有实现类必须添加 `@Service` 注解
-- 重写规则使用 `@Primary` 注解（推荐）
-- 日志记录使用 `@Slf4j` 注解
-
-### 向后兼容
-- 扩展DTO字段时，新字段应支持null值
-- 新字段为null时应保持原有行为
-- 在toString方法中包含所有字段
-
-## 快速开始示例
-
-假设需要为限额累计金额规则（`PriceLimitSumAmountHandlerExtension`）添加场景类型选择功能：
-
-1. **扩展DTO**：在 `PriceLimitSumAmountDTO` 中添加 `sceneTypes` 字段
-2. **创建定制实现**：创建 `CrossScenePriceLimitSumAmountHandlerImpl`，位于 `net.xnzn.yunshitang.marketing.handler`，使用 `@Primary` 注解
-3. **实现逻辑**：在 `handle()` 方法中使用 `sceneTypes` 字段过滤订单
-4. **向后兼容**：`sceneTypes` 为null时查询所有场景
-
-```java
-// 1. 扩展DTO（在核心工程包名下覆盖）
-// 位置：net.xnzn.core.marketing.v2.rule.price.handler.limitsum.dto.PriceLimitSumAmountDTO
-@Data
-@ApiModel("限额-累计金额规则详情")
-public class PriceLimitSumAmountDTO {
-    @ApiModelProperty("累计金额限额（分）")
-    private BigDecimal limitAmount;
-
-    // 扩展字段：场景类型列表，null时表示所有场景
-    @ApiModelProperty("适用场景类型（null=所有）")
-    private List<Integer> sceneTypes;
-
-    @Override
-    public String toString() {
-        return "limitAmount=" + limitAmount + ", sceneTypes=" + sceneTypes;
-    }
-}
-
-// 2. 定制实现（在yunshitang项目包下）
-// 位置：net.xnzn.yunshitang.marketing.handler
-@Slf4j
-@Service
-@Primary
-public class CrossScenePriceLimitSumAmountHandlerImpl
-        implements PriceLimitSumAmountHandlerExtension {
-
-    @Autowired
-    private MarketRuleRangeService rangeService;
-
-    @Override
-    public void handle(RulePriceResultOrderDTO order, MarketRuleVO rule,
-                      List<RulePriceResultOrderDTO> orderResults) {
-        PriceLimitSumAmountDTO ruleInfo = JSON.parseObject(
-            rule.getRuleInfo(), PriceLimitSumAmountDTO.class);
-
-        // 场景过滤（向后兼容：null时不过滤）
-        if (CollUtil.isNotEmpty(ruleInfo.getSceneTypes())
-                && !ruleInfo.getSceneTypes().contains(order.getSceneType())) {
-            return; // 不在适用场景内，跳过
-        }
-
-        // 原有累计金额限额逻辑...
-        BigDecimal sumAmount = calcSumAmount(order, orderResults);
-        if (sumAmount.compareTo(ruleInfo.getLimitAmount()) >= 0) {
-            throw new LeException("已超出累计消费限额");
-        }
-    }
-}
-```
-
-## 参考文档
-
-详见：[leniu-tengyun-core 源码](/Users/xujiajun/Developer/gongsi_proj/core/leniu-tengyun-core)