ai-engineering-init 1.17.0 → 1.17.2

package/.claude/hooks/skill-forced-eval.js

@@ -117,6 +117,7 @@ const instructions = `## 强制技能激活流程（必须执行）
 - skill-creator: 创建技能模板/技能脚手架/skill scaffold
 - leniu-report-scenario: 报表/报表开发/报表查询/报表导出/合计行/totalLine/汇总报表/定制报表/report_order_info/金额处理/分转元/餐次/mealtime/ReportBaseTotalVO/CustomNumberConverter
 - leniu-marketing-scenario: 营销/营销规则/消费规则/计价规则/充值规则/扣款规则/就餐规则/折扣/满减/限额/限次/补贴/赠送/满赠/管理费/MarketApi/RulePriceHandler/RuleRechargeHandler/RulePayHandler/MarketRule/规则定制
+- jenkins-deploy: 打包/部署/Jenkins/构建/Portainer/发布到dev/发布到test/更新环境/自动部署
 
 ### 步骤 2 - 激活（逐个调用，等待每个完成）
 

package/.claude/skills/jenkins-deploy/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: jenkins-deploy
+description: |
+  Jenkins + Portainer 自动打包部署技能。通过 Python 脚本调用 Jenkins API 构建项目，并触发 Portainer Webhook/Update 完成容器更新。
+
+  触发场景：
+  - 需要将代码打包部署到 dev/test 环境
+  - 需要触发 Jenkins 构建 core 或 api 项目
+  - 需要更新 Portainer 容器服务
+  - 需要查看或修改构建配置（分支、环境、模式）
+  - 定制项目的打包部署
+
+  触发词：打包、部署、Jenkins、构建、Portainer、发布到dev、发布到test、更新环境、自动部署
+---
+
+# Jenkins + Portainer 自动打包部署
+
+## 架构
+
+```
+技能目录（随框架更新，不复制到项目）:
+  ~/.claude/skills/jenkins-deploy/assets/jk_build.py     ← 构建脚本
+
+全局配置（一次性配置，所有项目共享）:
+  ~/.claude/jenkins-config.json                           ← 凭证（Jenkins/Portainer）
+
+项目本地（自动生成）:
+  jenkins/last_cd_env.json                                ← 构建状态（环境、分支、模式）
+```
+
+脚本按 **本地 `.claude/` > 全局 `~/.claude/`** 优先级查找 `jenkins-config.json`。
+
+## 构建模式
+
+| 模式 | 说明 | 执行步骤 |
+|------|------|---------|
+| `0` | 只构建 | 构建 core + api，不更新 Portainer |
+| `1` | 全构建+更新 | 构建 core + api → 触发 Portainer 更新 |
+| `2` | 构建 api+更新 | 跳过 core，构建 api → 触发 Portainer 更新 |
+| `3` | 只更新 | 不构建，直接触发 Portainer 更新 |
+
+## 环境支持
+
+| 环境 | 前缀 | Portainer 更新方式 |
+|------|------|-------------------|
+| dev1~15 | `dev` | Webhook 触发 |
+| dev16~43 | `dev` | Force Update（xnzn-dev.xnzn.net） |
+| dev44+ | `dev` | 只支持模式 0（手动更新） |
+| test | `test` | Webhook 触发 |
+
+## 使用方式
+
+### 运行构建脚本
+
+```bash
+python ~/.claude/skills/jenkins-deploy/assets/jk_build.py
+```
+
+脚本交互式询问：模式 → 环境 → core 分支 → api 分支 → 定制工程文件夹
+
+### 通过 AI 辅助部署
+
+当用户说"打包到 devX"时：
+
+1. 读取 `jenkins/last_cd_env.json` 获取上次参数
+2. 确认参数：环境、分支、模式
+3. 修改 `jenkins/last_cd_env.json` 写入新参数
+4. 执行 `python ~/.claude/skills/jenkins-deploy/assets/jk_build.py`
+
+## 配置文件
+
+### jenkins-config.json（凭证，全局）
+
+位置：`~/.claude/jenkins-config.json`（或本地 `.claude/jenkins-config.json`）
+
+模板：`.claude/skills/jenkins-deploy/assets/env_param.template.json`
+
+> **注意**：此文件包含敏感凭证，不要将内容输出到对话中。
+
+### last_cd_env.json（构建状态，项目本地）
+
+位置：`jenkins/last_cd_env.json`（脚本自动创建，无需手动初始化）
+
+```json
+{
+  "build_mode": "1",
+  "cd_env": "dev1",
+  "core_param_branch": "master",
+  "api_param_branch": "master",
+  "api_param_folder": null
+}
+```
+
+## 定制项目
+
+指定 `api_param_folder` 后，Jenkins Job 路径变为：
+
+```
+{folder_name}/dev-后端-core
+{folder_name}/dev-后端-api
+```
+
+## 首次初始化（团队成员）
+
+只需一步：配置全局凭证文件。
+
+```bash
+# 方式 1：从团队成员拷贝
+cp /path/to/teammate/jenkins-config.json ~/.claude/jenkins-config.json
+
+# 方式 2：从模板创建，手动填写凭证
+cp ~/.claude/skills/jenkins-deploy/assets/env_param.template.json ~/.claude/jenkins-config.json
+# 然后替换 __JENKINS_*__ 和 __PORTAINER_*__ 占位符
+```
+
+### AI 初始化行为
+
+当技能被触发但 `jenkins-config.json` 不存在时：
+1. 提示"检测到尚未配置 Jenkins 凭证"
+2. 询问是否从模板创建
+3. 复制模板到 `~/.claude/jenkins-config.json`
+4. 提示用户填写凭证（或拷贝已有配置）
+
+## 依赖
+
+```bash
+pip install python-jenkins requests
+```
+
+## 注意
+
+- 本技能用于 dev/test 环境部署，**不涉及生产环境**
+- 如果是 Git 提交/分支管理，请使用 `git-workflow` 技能
+- 如果是代码构建错误排查，请使用 `bug-detective` 技能

package/.claude/skills/jenkins-deploy/assets/env_param.template.json

@@ -0,0 +1,51 @@
+{
+  "portainer_api_url": {
+    "dev": "https://devops-dev.xnzn.net/api",
+    "dev16": "https://xnzn-dev.xnzn.net/api",
+    "test": "https://devops-test.xnzn.net/api"
+  },
+  "portainer_user_name": {
+    "dev": "__PORTAINER_DEV_USER__",
+    "dev16": "__PORTAINER_DEV16_USER__",
+    "test": "__PORTAINER_TEST_USER__"
+  },
+  "portainer_user_pwd": {
+    "dev": "__PORTAINER_DEV_PWD__",
+    "dev16": "__PORTAINER_DEV16_PWD__",
+    "test": "__PORTAINER_TEST_PWD__"
+  },
+  "portainer_endpoints": {
+    "dev": "2",
+    "dev16": "1",
+    "test": "2"
+  },
+  "portainer_server_suffix": {
+    "dev": "_yunshitang-api",
+    "dev16": "_yunshitang-api-offline",
+    "test": "_yunshitang-api"
+  },
+  "core_job": {
+    "dev": "dev-tengyun-core",
+    "test": "test-tengyun-core"
+  },
+  "core_job_custom": {
+    "dev": "dev-后端-core",
+    "test": "test-后端-core"
+  },
+  "api_job": {
+    "dev": "dev-tengyun-yunshitang-api",
+    "test": "test-tengyun-yunshitang-api"
+  },
+  "api_job_custom": {
+    "dev": "dev-后端-api",
+    "test": "test-后端-api"
+  },
+  "jenkins_user_id": {
+    "dev": "__JENKINS_DEV_USER__",
+    "test": "__JENKINS_TEST_USER__"
+  },
+  "jenkins_api_token": {
+    "dev": "__JENKINS_DEV_TOKEN__",
+    "test": "__JENKINS_TEST_TOKEN__"
+  }
+}

package/.claude/skills/jenkins-deploy/assets/jk_build.py

@@ -0,0 +1,400 @@
+# 简单调用jenkins api，构建项目并触发webhook
+import html
+import json
+import os
+import sys
+import time
+
+import jenkins
+import requests
+
+# 预设默认值（可修改）
+cd_env = ''  # dev或test
+
+# dev和test环境独立配置
+jenkins_server_url = 'https://ci.xnzn.net'  # jenkins地址
+portainer_server_suffix = ''  # portainer服务名后缀
+core_timeout = 60 * 10  # core构建超时时间
+api_timeout = 60 * 5  # api构建超时时间
+portainer_user_name = ''  # portainer用户名
+portainer_user_pwd = ''  # portainer密码
+portainer_api_url = ''
+portainer_endpoints = ''
+jenkins_user_id = ''
+jenkins_api_token = ''
+core_job = ''
+api_job = ''
+
+
+# ~~~~~~~~~~~~~~~~~ 配置文件查找 ~~~~~~~~~~~~~~~~~~~~~~~~
+
+def find_config_file(filename, search_paths):
+    """按优先级查找配置文件：本地 > 全局"""
+    for p in search_paths:
+        filepath = os.path.join(p, filename)
+        if os.path.exists(filepath):
+            return filepath
+    return None
+
+
+# 配置文件搜索路径
+project_dir = os.getcwd()
+home_claude_dir = os.path.join(os.path.expanduser('~'), '.claude')
+
+# jenkins-config.json 搜索路径：项目本地 .claude/ > 全局 ~/.claude/
+config_search_paths = [
+    os.path.join(project_dir, '.claude'),
+    home_claude_dir,
+]
+
+# last_cd_env.json 搜索路径：项目本地 jenkins/
+state_dir = os.path.join(project_dir, 'jenkins')
+
+
+# 执行job方法，通过等待时间来判断是否构建成功
+def do_job_by_time(server, job_name, param_branch, param_env, wait_time):
+    queue_num = server.build_job(name=job_name,
+                                 parameters={'BRANCH': param_branch, 'VERSION': param_env},
+                                 token=jenkins_api_token)
+    print('创建queue... {queue_num}')
+    time.sleep(wait_time)
+    queue_info = server.get_queue_item(queue_num)
+
+    print('等待时间到，queue信息：' + str(queue_info))
+
+
+# 执行job方法，通过请求判断结束，进度更准确
+def do_job(server, job_name, param_branch, param_env, wait_time):
+
+    queue_num = server.build_job(name=job_name,
+                                 parameters={'BRANCH': param_branch, 'VERSION': param_env},
+                                 token=jenkins_api_token)
+    print(f'创建队列... {queue_num}')
+    job_number = None
+    # 记录开始构建时间
+    start_time = time.time()
+
+    while True:
+        time.sleep(10)
+        if time.time() - start_time > wait_time:
+            print("构建超时，结束")
+            exit(1)
+        queue_info = server.get_queue_item(queue_num)
+        if queue_info['why'] is not None:
+            why = queue_info['why']
+            print(f'队列等待执行器...{why}')
+        elif 'executable' in queue_info:
+            job_number = queue_info['executable']['number']
+            print(f'开始执行任务...{job_number}')
+            break
+        else:
+            print('执行结束')
+            break
+
+    # 间隔x秒查询构建结果
+    while True:
+        time.sleep(10)
+
+        # 如果超过3分钟，直接结束
+        if time.time() - start_time > wait_time:
+            print("构建超时，结束")
+            exit(1)
+        headers = {
+            "n": str(job_number),
+        }
+        # 如果job_name包含 '/'，则在把'/'替换为/job/
+        if '/' in job_name:
+            job_name_url = job_name.replace('/', '/job/')
+            url = f'{jenkins_server_url}/job/{job_name_url}/buildHistory/ajax'
+        else:
+            url = f'{jenkins_server_url}/job/{job_name}/buildHistory/ajax'
+
+        req = requests.Request(method='POST', url=url, headers=headers)
+        response = server.jenkins_open(req)
+        # 解析response包含的html
+        html_str = html.unescape(response)
+        if 'Expected build number' in html_str:  # 正在等待中
+            print(f'\r等待中...', end='')
+            continue
+        elif ('预计剩余时间' in html_str) or ('Estimated remaining time' in html_str):  # 是否包含 预计剩余时间
+            try:
+                # 取出 '<td style="width:' 和 '%;" class="progress-bar-done"></td>' 之间的字符串
+                progress = html_str.split('<td style="width:')[1].split('%;" class="progress-bar-done"></td>')[0]
+                # 打印进度更新最后一行
+                print(f'\r构建中...{progress}%', end='')
+            except IndexError:
+                print("无法从HTML字符串中提取进度信息")
+            except Exception as e:
+                print(f"发生错误: {e}")
+            continue
+        else:
+            print(f"\r构建结束，耗时 {(time.time() - start_time):.2f} 秒", end='\n')
+            # 查询构建结果
+            build_info = server.get_build_info(job_name, job_number)
+            if build_info['result'] == 'SUCCESS':
+                print(f"构建成功 {html.unescape(build_info['url'])}")
+            else:
+                print(f"构建失败（{build_info['result']}） {html.unescape(build_info['url'])}")
+                print(f"原始 build_info：{build_info}")
+                print(f"原始 html：{html_str}")
+                return False
+            break
+    return True
+
+
+# 获取 Portainer JWT Token
+def get_jwt_token():
+    login_url = f"{portainer_api_url}/auth"
+    login_data = {
+        "Username": portainer_user_name,
+        "Password": portainer_user_pwd,
+    }
+    response = requests.post(login_url, data=json.dumps(login_data))
+    token = response.json()["jwt"]
+    print('获取token成功')
+    return token
+
+
+# 获取 Service ID
+def get_server_id(token):
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    url = portainer_api_url + f'/endpoints/{portainer_endpoints}/docker/services'
+    services_response = requests.get(url, headers=headers)
+    services = services_response.json()
+
+    service_name = cd_env + portainer_server_suffix
+    # Find service with matching name
+    target_service_id = None
+    for service in services:
+        if service["Spec"]["Name"] == service_name:
+            target_service_id = service["ID"]
+            break
+
+    print(f'查询{service_name}的service_id：{target_service_id}')
+    return target_service_id
+
+
+# 获取 Service 的 WebHook
+def get_service_web_hook():
+    pt_token = get_jwt_token()
+    service_id = get_server_id(pt_token)
+
+    headers = {
+        "Authorization": f"Bearer {pt_token}",
+        "Content-Type": "application/json"
+    }
+
+    url = portainer_api_url + f'/webhooks?filters=%7B%22ResourceID%22:%22{service_id}%22,%22EndpointID%22:{portainer_endpoints}%7D'
+    services_response = requests.get(url, headers=headers)
+    webhook_json = services_response.json()
+    target_webhook_token = None
+    # 是否存在webhook
+    if len(webhook_json) > 0:
+        target_webhook_token = webhook_json[0]['Token']
+        print('获取webhook_token：' + target_webhook_token)
+
+    #  尝试调用请求创建webhook
+    if target_webhook_token is None:
+        payload = {"ResourceID": service_id, "EndpointID": 2, "WebhookType": 1, "registryID": 0}
+        services_response = requests.post(portainer_api_url + "/webhooks", headers=headers, data=json.dumps(payload))
+        webhook_json = services_response.json()
+        if webhook_json is not None and 'Token' in webhook_json:
+            target_webhook_token = webhook_json['Token']
+        print('创建webhook_token结果：' + target_webhook_token)
+
+    return target_webhook_token
+
+
+# 启动webhook（dev1-15）
+def trigger_webhook():
+
+    wh_token = get_service_web_hook()
+
+    if wh_token is None:
+        print(f"{cd_env}环境没有配置webhook，结束")
+        exit(0)
+    else:
+        print("开始触发webhook")
+        r = requests.post(portainer_api_url + '/webhooks/' + wh_token)
+        print("webhook触发结果：" + str(r.status_code))
+
+# 通过service id 更新
+def update_portainer():
+
+    pt_token = get_jwt_token()
+    service_id = get_server_id(pt_token)
+
+    headers = {
+        "Authorization": f"Bearer {pt_token}",
+        "Content-Type": "application/json"
+    }
+
+    # 调用更新（PUT请求）：
+    url = portainer_api_url + f'/endpoints/{portainer_endpoints}/forceupdateservice'
+    payload = {
+        "serviceID": service_id,
+        "pullImage": True,
+    }
+    services_response = requests.put(url, headers=headers, data=json.dumps(payload))
+    update_rsp_json = services_response.json()
+    print('更新结果：' + str(update_rsp_json))
+
+# ~~~~~~~~~~~~~~~~~~ 开始输入 ~~~~~~~~~~~~~~~~~~~~~~~
+
+# 打印欢迎信息
+print('\n~~~~~~~~~~~~~~')
+print('正在使用jenkins+portainer构建工具，目前支持dev和test环境的自动化构建+更新')
+print('~~~~~~~~~~~~~~\n')
+
+# 查找环境配置文件（jenkins-config.json）
+config_file = find_config_file('jenkins-config.json', config_search_paths)
+if config_file is None:
+    print('❌ 未找到 jenkins-config.json')
+    print(f'  请将配置文件放到以下任一位置：')
+    for p in config_search_paths:
+        print(f'    - {os.path.join(p, "jenkins-config.json")}')
+    print(f'\n  或运行: npx ai-engineering-init config --type jenkins')
+    exit(1)
+print(f'配置文件: {config_file}')
+
+# 确保构建状态目录存在
+os.makedirs(state_dir, exist_ok=True)
+state_file = os.path.join(state_dir, 'last_cd_env.json')
+
+# 读取上一次构建的环境（如果不存在则使用默认值）
+if os.path.exists(state_file):
+    with open(state_file, 'r', encoding='utf-8') as f:
+        cd_env_json = json.load(f)
+else:
+    cd_env_json = {
+        "build_mode": "1",
+        "cd_env": "dev1",
+        "core_param_branch": "master",
+        "api_param_branch": "master",
+        "api_param_folder": None
+    }
+
+# 从终端获取用户输入模式
+build_mode = input(f"请输入模式 0-只构建 1-全构建+更新 2-构建api+更新 3-只更新（预设{cd_env_json['build_mode']}）：", ) or cd_env_json['build_mode']
+
+# 从终端获取用户输入cd_env
+cd_env = input(f"请输入环境（预设：{cd_env_json['cd_env']}）:", ) or cd_env_json['cd_env']
+
+# 从终端获取用户输入的分支
+core_param_branch = input(f"请输入core分支（预设：{cd_env_json['core_param_branch']}）:") or cd_env_json['core_param_branch']
+
+# 从终端输入api分支
+api_param_branch = input(f"请输入api分支（预设：{cd_env_json['api_param_branch']}）:") or cd_env_json['api_param_branch']
+
+# 从终端输入api文件夹名
+api_param_folder = input(f"请输入定制工程文件夹名（空格或None表示不需要，预设：{cd_env_json['api_param_folder']}）:") or cd_env_json['api_param_folder']
+
+# 校验模式：
+if build_mode is None or build_mode not in ('0', '1', '2', '3'):
+    print("模式错误，结束")
+    exit(1)
+# 校验环境，如果不是dev或test开头的，直接退出
+if cd_env is None or not cd_env.startswith('dev') and not cd_env.startswith('test'):
+    print("环境错误，结束")
+    exit(1)
+# 校验分支
+if core_param_branch is None:
+    print("分支错误，结束")
+    exit(1)
+if api_param_branch is None:
+    print("分支错误，结束")
+    exit(1)
+if api_param_folder is None or api_param_folder == '' or api_param_folder == ' ' or api_param_folder == 'none' or api_param_folder == 'None':
+    api_param_folder = None
+# 如果dev44及以上环境，只能使用模式0：
+if cd_env.startswith('dev') and int(cd_env[3:]) >= 44 and build_mode != '0':
+    print("dev43及以上环境只能使用模式0，结束")
+    exit(1)
+
+# 保存到本地状态文件
+cd_env_json['cd_env'] = cd_env
+cd_env_json['core_param_branch'] = core_param_branch
+cd_env_json['api_param_branch'] = api_param_branch
+cd_env_json['api_param_folder'] = api_param_folder
+cd_env_json['build_mode'] = build_mode
+json.dump(cd_env_json, open(state_file, 'w', encoding='utf-8'), ensure_ascii=False)
+
+# 根据环境输入，设置前缀
+env_prefix = 'dev' if cd_env.startswith('dev') else 'test'
+
+# 读取环境配置（从全局或本地 jenkins-config.json）
+with open(config_file, 'r', encoding='utf-8') as f:
+    env_param = json.load(f)
+
+jenkins_user_id = env_param['jenkins_user_id'][env_prefix]
+jenkins_api_token = env_param['jenkins_api_token'][env_prefix]
+core_job = env_param['core_job'][env_prefix]
+api_job = env_param['api_job'][env_prefix]
+if api_param_folder is not None:
+    core_job = api_param_folder + '/' + env_param['core_job_custom'][env_prefix]
+    api_job = api_param_folder + '/' + env_param['api_job_custom'][env_prefix]
+
+# portainer配置（如果cd_env > dev15，使用另一套配置）
+if cd_env.startswith('dev') and int(cd_env[3:]) > 15:
+    portainer_user_name = env_param['portainer_user_name']['dev16']
+    portainer_user_pwd = env_param['portainer_user_pwd']['dev16']
+    portainer_api_url = env_param['portainer_api_url']['dev16']
+    portainer_endpoints = env_param['portainer_endpoints']['dev16']
+    portainer_server_suffix = env_param['portainer_server_suffix']['dev16']
+else:
+    portainer_api_url = env_param['portainer_api_url'][env_prefix]
+    portainer_user_name = env_param['portainer_user_name'][env_prefix]
+    portainer_user_pwd = env_param['portainer_user_pwd'][env_prefix]
+    portainer_endpoints = env_param['portainer_endpoints'][env_prefix]
+    portainer_server_suffix = env_param['portainer_server_suffix'][env_prefix]
+
+# ~~~~~~~~~~~~~~~~~ 开始打包 ~~~~~~~~~~~~~~~~~~~~~~~~
+
+print('\n~~~~~~~~~~~~~~\n')
+print('开始打包')
+print("链接jenkins：" + jenkins_server_url)
+
+# 实例化jenkins对象，连接远程的jenkins master server
+j_server = jenkins.Jenkins(url=jenkins_server_url, username=jenkins_user_id, password=jenkins_api_token)
+print("jenkins信息：" + j_server.get_whoami()['fullName'])
+
+# 通过参数构建core
+if int(build_mode) < 2:
+    print('开始构建core：' + core_job + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+    rs = do_job(j_server, core_job, core_param_branch, cd_env, core_timeout)
+    if rs is False:
+        print('构建core失败，结束')
+        exit(1)
+    time.sleep(10)
+
+if int(build_mode) < 3:
+    print('开始构建api：' + api_job + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+    rs = do_job(j_server, api_job, api_param_branch, cd_env, api_timeout)
+    if rs is False:
+        print('构建api失败，结束')
+        exit(1)
+    time.sleep(2)
+
+print('结束打包' + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+
+# ~~~~~~~~~~~~~~~~~ 开始更新 ~~~~~~~~~~~~~~~~~~~~~~~~
+
+# 开始更新portainer
+if int(build_mode) == 0:
+    print('\n~~~~~~~ 请自行更新portainer ~~~~~~~\n')
+else:
+    print('\n~~~~~~~~~~~~~~\n')
+    print('开始更新portainer：' + portainer_api_url + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+    # portainer配置（如果cd_env > dev15，使用update）
+    if cd_env.startswith('dev') and int(cd_env[3:]) > 15:
+        # 通过update更新
+        update_portainer()
+    else:
+        # 触发webhook
+        trigger_webhook()
+
+
+exit(0)

package/.codex/skills/jenkins-deploy/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: jenkins-deploy
+description: |
+  Jenkins + Portainer 自动打包部署技能。通过 Python 脚本调用 Jenkins API 构建项目，并触发 Portainer Webhook/Update 完成容器更新。
+
+  触发场景：
+  - 需要将代码打包部署到 dev/test 环境
+  - 需要触发 Jenkins 构建 core 或 api 项目
+  - 需要更新 Portainer 容器服务
+  - 需要查看或修改构建配置（分支、环境、模式）
+  - 定制项目的打包部署
+
+  触发词：打包、部署、Jenkins、构建、Portainer、发布到dev、发布到test、更新环境、自动部署
+---
+
+# Jenkins + Portainer 自动打包部署
+
+## 架构
+
+```
+技能目录（随框架更新，不复制到项目）:
+  ~/.claude/skills/jenkins-deploy/assets/jk_build.py     ← 构建脚本
+
+全局配置（一次性配置，所有项目共享）:
+  ~/.claude/jenkins-config.json                           ← 凭证（Jenkins/Portainer）
+
+项目本地（自动生成）:
+  jenkins/last_cd_env.json                                ← 构建状态（环境、分支、模式）
+```
+
+脚本按 **本地 `.claude/` > 全局 `~/.claude/`** 优先级查找 `jenkins-config.json`。
+
+## 构建模式
+
+| 模式 | 说明 | 执行步骤 |
+|------|------|---------|
+| `0` | 只构建 | 构建 core + api，不更新 Portainer |
+| `1` | 全构建+更新 | 构建 core + api → 触发 Portainer 更新 |
+| `2` | 构建 api+更新 | 跳过 core，构建 api → 触发 Portainer 更新 |
+| `3` | 只更新 | 不构建，直接触发 Portainer 更新 |
+
+## 环境支持
+
+| 环境 | 前缀 | Portainer 更新方式 |
+|------|------|-------------------|
+| dev1~15 | `dev` | Webhook 触发 |
+| dev16~43 | `dev` | Force Update（xnzn-dev.xnzn.net） |
+| dev44+ | `dev` | 只支持模式 0（手动更新） |
+| test | `test` | Webhook 触发 |
+
+## 使用方式
+
+### 运行构建脚本
+
+```bash
+python ~/.claude/skills/jenkins-deploy/assets/jk_build.py
+```
+
+脚本交互式询问：模式 → 环境 → core 分支 → api 分支 → 定制工程文件夹
+
+### 通过 AI 辅助部署
+
+当用户说"打包到 devX"时：
+
+1. 读取 `jenkins/last_cd_env.json` 获取上次参数
+2. 确认参数：环境、分支、模式
+3. 修改 `jenkins/last_cd_env.json` 写入新参数
+4. 执行 `python ~/.claude/skills/jenkins-deploy/assets/jk_build.py`
+
+## 配置文件
+
+### jenkins-config.json（凭证，全局）
+
+位置：`~/.claude/jenkins-config.json`（或本地 `.claude/jenkins-config.json`）
+
+模板：`.claude/skills/jenkins-deploy/assets/env_param.template.json`
+
+> **注意**：此文件包含敏感凭证，不要将内容输出到对话中。
+
+### last_cd_env.json（构建状态，项目本地）
+
+位置：`jenkins/last_cd_env.json`（脚本自动创建，无需手动初始化）
+
+```json
+{
+  "build_mode": "1",
+  "cd_env": "dev1",
+  "core_param_branch": "master",
+  "api_param_branch": "master",
+  "api_param_folder": null
+}
+```
+
+## 定制项目
+
+指定 `api_param_folder` 后，Jenkins Job 路径变为：
+
+```
+{folder_name}/dev-后端-core
+{folder_name}/dev-后端-api
+```
+
+## 首次初始化（团队成员）
+
+只需一步：配置全局凭证文件。
+
+```bash
+# 方式 1：从团队成员拷贝
+cp /path/to/teammate/jenkins-config.json ~/.claude/jenkins-config.json
+
+# 方式 2：从模板创建，手动填写凭证
+cp ~/.claude/skills/jenkins-deploy/assets/env_param.template.json ~/.claude/jenkins-config.json
+# 然后替换 __JENKINS_*__ 和 __PORTAINER_*__ 占位符
+```
+
+### AI 初始化行为
+
+当技能被触发但 `jenkins-config.json` 不存在时：
+1. 提示"检测到尚未配置 Jenkins 凭证"
+2. 询问是否从模板创建
+3. 复制模板到 `~/.claude/jenkins-config.json`
+4. 提示用户填写凭证（或拷贝已有配置）
+
+## 依赖
+
+```bash
+pip install python-jenkins requests
+```
+
+## 注意
+
+- 本技能用于 dev/test 环境部署，**不涉及生产环境**
+- 如果是 Git 提交/分支管理，请使用 `git-workflow` 技能
+- 如果是代码构建错误排查，请使用 `bug-detective` 技能

package/.cursor/hooks/cursor-skill-eval.js

@@ -417,6 +417,10 @@ const skillMap = [
   {
     name: 'skill-creator',
     keywords: ['创建技能', '技能模板', '技能脚手架', 'skill scaffold', '新建skill']
+  },
+  {
+    name: 'jenkins-deploy',
+    keywords: ['打包', '部署', 'Jenkins', '构建', 'Portainer', '发布到dev', '发布到test', '更新环境', '自动部署']
   }
 ];
 

package/.cursor/rules/skill-activation.mdc

@@ -87,6 +87,7 @@ alwaysApply: true
 | 多租户/租户隔离/TenantEntity/tenantId/SaaS | `.cursor/skills/tenant-management/SKILL.md` |
 | Element UI/前端组件/el-table/el-form/管理页面 | `.cursor/skills/ui-pc/SKILL.md` |
 | Vuex/store/mapState/mapActions/状态管理 | `.cursor/skills/store-pc/SKILL.md` |
+| 打包/部署/Jenkins/构建/Portainer/发布到dev/发布到test/自动部署 | `.cursor/skills/jenkins-deploy/SKILL.md` |
 
 ### 执行规则
 

package/.cursor/skills/jenkins-deploy/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: jenkins-deploy
+description: |
+  Jenkins + Portainer 自动打包部署技能。通过 Python 脚本调用 Jenkins API 构建项目，并触发 Portainer Webhook/Update 完成容器更新。
+
+  触发场景：
+  - 需要将代码打包部署到 dev/test 环境
+  - 需要触发 Jenkins 构建 core 或 api 项目
+  - 需要更新 Portainer 容器服务
+  - 需要查看或修改构建配置（分支、环境、模式）
+  - 定制项目的打包部署
+
+  触发词：打包、部署、Jenkins、构建、Portainer、发布到dev、发布到test、更新环境、自动部署
+---
+
+# Jenkins + Portainer 自动打包部署
+
+## 架构
+
+```
+技能目录（随框架更新，不复制到项目）:
+  ~/.claude/skills/jenkins-deploy/assets/jk_build.py     ← 构建脚本
+
+全局配置（一次性配置，所有项目共享）:
+  ~/.claude/jenkins-config.json                           ← 凭证（Jenkins/Portainer）
+
+项目本地（自动生成）:
+  jenkins/last_cd_env.json                                ← 构建状态（环境、分支、模式）
+```
+
+脚本按 **本地 `.claude/` > 全局 `~/.claude/`** 优先级查找 `jenkins-config.json`。
+
+## 构建模式
+
+| 模式 | 说明 | 执行步骤 |
+|------|------|---------|
+| `0` | 只构建 | 构建 core + api，不更新 Portainer |
+| `1` | 全构建+更新 | 构建 core + api → 触发 Portainer 更新 |
+| `2` | 构建 api+更新 | 跳过 core，构建 api → 触发 Portainer 更新 |
+| `3` | 只更新 | 不构建，直接触发 Portainer 更新 |
+
+## 环境支持
+
+| 环境 | 前缀 | Portainer 更新方式 |
+|------|------|-------------------|
+| dev1~15 | `dev` | Webhook 触发 |
+| dev16~43 | `dev` | Force Update（xnzn-dev.xnzn.net） |
+| dev44+ | `dev` | 只支持模式 0（手动更新） |
+| test | `test` | Webhook 触发 |
+
+## 使用方式
+
+### 运行构建脚本
+
+```bash
+python ~/.claude/skills/jenkins-deploy/assets/jk_build.py
+```
+
+脚本交互式询问：模式 → 环境 → core 分支 → api 分支 → 定制工程文件夹
+
+### 通过 AI 辅助部署
+
+当用户说"打包到 devX"时：
+
+1. 读取 `jenkins/last_cd_env.json` 获取上次参数
+2. 确认参数：环境、分支、模式
+3. 修改 `jenkins/last_cd_env.json` 写入新参数
+4. 执行 `python ~/.claude/skills/jenkins-deploy/assets/jk_build.py`
+
+## 配置文件
+
+### jenkins-config.json（凭证，全局）
+
+位置：`~/.claude/jenkins-config.json`（或本地 `.claude/jenkins-config.json`）
+
+模板：`.claude/skills/jenkins-deploy/assets/env_param.template.json`
+
+> **注意**：此文件包含敏感凭证，不要将内容输出到对话中。
+
+### last_cd_env.json（构建状态，项目本地）
+
+位置：`jenkins/last_cd_env.json`（脚本自动创建，无需手动初始化）
+
+```json
+{
+  "build_mode": "1",
+  "cd_env": "dev1",
+  "core_param_branch": "master",
+  "api_param_branch": "master",
+  "api_param_folder": null
+}
+```
+
+## 定制项目
+
+指定 `api_param_folder` 后，Jenkins Job 路径变为：
+
+```
+{folder_name}/dev-后端-core
+{folder_name}/dev-后端-api
+```
+
+## 首次初始化（团队成员）
+
+只需一步：配置全局凭证文件。
+
+```bash
+# 方式 1：从团队成员拷贝
+cp /path/to/teammate/jenkins-config.json ~/.claude/jenkins-config.json
+
+# 方式 2：从模板创建，手动填写凭证
+cp ~/.claude/skills/jenkins-deploy/assets/env_param.template.json ~/.claude/jenkins-config.json
+# 然后替换 __JENKINS_*__ 和 __PORTAINER_*__ 占位符
+```
+
+### AI 初始化行为
+
+当技能被触发但 `jenkins-config.json` 不存在时：
+1. 提示"检测到尚未配置 Jenkins 凭证"
+2. 询问是否从模板创建
+3. 复制模板到 `~/.claude/jenkins-config.json`
+4. 提示用户填写凭证（或拷贝已有配置）
+
+## 依赖
+
+```bash
+pip install python-jenkins requests
+```
+
+## 注意
+
+- 本技能用于 dev/test 环境部署，**不涉及生产环境**
+- 如果是 Git 提交/分支管理，请使用 `git-workflow` 技能
+- 如果是代码构建错误排查，请使用 `bug-detective` 技能

package/AGENTS.md

@@ -94,6 +94,7 @@
 | `collaborating-with-gemini` | 与 Gemini 协同设计 |
 | `codex-code-review` | 代码审查 |
 | `leniu-marketing-scenario` | 营销规则开发（折扣/满减/限额/限次/补贴/充值赠送/扣款/就餐规则） |
+| `jenkins-deploy` | 打包部署（Jenkins 构建 + Portainer 更新，dev/test 环境） |
 
 ### OpenSpec 规格驱动开发技能（SDD）
 

package/bin/index.js

@@ -586,6 +586,30 @@ function showDoneHint(toolKey) {
     console.log(`  2. 在 Codex 中使用 .codex/skills/ 下的技能`);
     console.log('');
   }
+  showJenkinsHint();
+}
+
+/** 检测 jenkins/ 是否已初始化，提示用户配置部署环境 */
+function showJenkinsHint() {
+  const homeClaudeDir = path.join(os.homedir(), '.claude');
+  const globalConfig = path.join(homeClaudeDir, 'jenkins-config.json');
+  const localConfig = path.join(targetDir, '.claude', 'jenkins-config.json');
+  const skillAssetsDir = path.join(targetDir, '.claude', 'skills', 'jenkins-deploy', 'assets');
+  // 全局安装时也检查全局技能目录
+  const globalSkillDir = path.join(homeClaudeDir, 'skills', 'jenkins-deploy', 'assets');
+
+  const hasSkill = fs.existsSync(skillAssetsDir) || fs.existsSync(globalSkillDir);
+  const hasConfig = fs.existsSync(globalConfig) || fs.existsSync(localConfig);
+
+  // 技能存在但凭证未配置
+  if (hasSkill && !hasConfig) {
+    console.log(fmt('yellow', fmt('bold', '📦 Jenkins 部署凭证未配置')));
+    console.log(`  已安装 ${fmt('bold', 'jenkins-deploy')} 技能，但 ${fmt('bold', 'jenkins-config.json')} 尚未配置。`);
+    console.log(`  配置方式：`);
+    console.log(`    方式 1：从团队成员处拷贝 ${fmt('bold', '~/.claude/jenkins-config.json')}`);
+    console.log(`    方式 2：在 AI 对话中说 ${fmt('bold', '"初始化部署环境"')}`);
+    console.log('');
+  }
 }
 
 function run(selectedTool) {
@@ -748,6 +772,7 @@ function runUpdate(selectedTool) {
     console.log(`  强制更新保留文件: ${fmt('bold', hintCmd('update --force'))}`);
   }
   console.log('');
+  showJenkinsHint();
 
   if (totalFailed > 0) process.exitCode = 1;
 }

package/package.json

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