@elvis1513/auto-coding-skill 0.1.3 → 0.2.0

package/README.md

@@ -1,10 +1,14 @@
 # auto-coding-skill
 
-Framework-agnostic engineering workflow skill for:
+Engineering workflow skill for:
 
 - Claude Code
 - Codex CLI
 
+This branch is specialized for Go backend + frontend monorepo projects that build Docker images locally, validate with project `docker compose`, and rely on Jenkins to auto-build and update target environments after push.
+It supports both Claude and Codex. During development, it should prefer already available MCP servers, installed skills, plugins, and app connectors for design, research, documentation, verification, and external system updates.
+It should also prefer multi-agent execution whenever the work can be split into parallel subtasks safely.
+
 ## Install
 
 ```bash
@@ -38,7 +42,7 @@ python3 .claude/skills/auto-coding-skill/scripts/ap.py --repo . install
 
 - `docs/ENGINEERING.md` frontmatter
 
-This frontmatter is the only manual config source (commands + deployment + docs paths).
+This frontmatter is the only manual config source (commands + local Docker runtime + Jenkins + docs paths).
 
 4. Start AI development by constraints:
 
@@ -50,6 +54,23 @@ This frontmatter is the only manual config source (commands + deployment + docs
 - `docs/bugs/bug-list.md`
 - `docs/tasks/summaries/**`
 
+5. Tool selection rule during execution:
+
+- Prefer current MCP/skills/plugins/apps first.
+- Fall back to shell/manual work only when those capabilities are unavailable or insufficient.
+
+6. Collaboration rule during execution:
+
+- Prefer multi-agent mode.
+- Split research, design, implementation, validation, and documentation into parallel subtasks whenever the boundaries are clear.
+- Keep one main agent responsible for integration and final gates.
+
+7. Delivery rule during execution:
+
+- Local `docker compose` validation must pass before commit.
+- `git push` is expected to trigger Jenkins automatically.
+- Task is not complete until Jenkins succeeds and the target environment health check passes.
+
 ## AGENTS.md Constraint Example
 
 ```md
@@ -67,16 +88,16 @@ This frontmatter is the only manual config source (commands + deployment + docs
 ### 1) docs/ENGINEERING.md
 - Purpose: single source of project config + engineering gate rules.
 - How to record:
-  - Fill YAML frontmatter once (project/commands/deployment/docs fields).
-  - Keep all environment info here only (ip/username/password/service/path/health).
+  - Fill YAML frontmatter once (project/commands/runtime/jenkins/docs fields).
+  - Keep all local runtime and Jenkins info here only (compose file/service/container/image/health/job/env).
   - Do not duplicate config in other docs.
 
 ### 2) docs/deployment/
 - Files:
-  - `docs/deployment/deploy-runbook.md`: deployment procedure and validation checklist.
-  - `docs/deployment/deploy-records/<TASK_ID>-YYYYMMDD.md`: per-deploy execution record.
+  - `docs/deployment/deploy-runbook.md`: local Compose validation + Jenkins deployment procedure.
+  - `docs/deployment/deploy-records/<TASK_ID>-YYYYMMDD.md`: local validation + Jenkins deployment evidence.
 - How to record:
-  - In deploy record, write target host, service, artifact, remote path, backup, systemctl status, smoke/regression evidence.
+  - Record both local Compose validation and Jenkins deployment evidence: compose file, service, container, image tag, Jenkins build, deploy env, health checks.
 
 ### 3) docs/design/
 - Files:
@@ -100,7 +121,7 @@ This frontmatter is the only manual config source (commands + deployment + docs
 - Files:
   - `docs/reviews/<TASK_ID>-<timestamp>.md` (from review template).
 - Purpose:
-  - Gate review evidence: static checks, code quality, test quality, risks.
+  - Gate review evidence: static checks, Go + frontend quality, local Compose validation, Jenkins readiness, risks.
 - How to record:
   - Record commands used (lint/typecheck from docs/ENGINEERING.md frontmatter) and conclusion (Pass/Blocked).
 
@@ -116,7 +137,7 @@ This frontmatter is the only manual config source (commands + deployment + docs
 - Files:
   - `docs/testing/regression-matrix.md`
 - Purpose:
-  - Full regression matrix; must be 0 FAIL.
+  - Full regression matrix against the local Compose environment; must be 0 FAIL.
 - How to record:
   - Add/maintain rows by regression ID (R-xxx), area, steps/command, expected, status, evidence.
   - If any FAIL exists, gate fails.
@@ -128,10 +149,18 @@ pip install pyyaml requests
 python3 scripts/autopipeline/ap.py run build
 python3 scripts/autopipeline/ap.py run test
 python3 scripts/autopipeline/ap.py run lint
+python3 scripts/autopipeline/ap.py run docker_build
+python3 scripts/autopipeline/ap.py runtime-up
+python3 scripts/autopipeline/ap.py wait-health
+python3 scripts/autopipeline/ap.py run smoke
+python3 scripts/autopipeline/ap.py run regression
+python3 scripts/autopipeline/ap.py runtime-down
+python3 scripts/autopipeline/ap.py verify-jenkins
+python3 scripts/autopipeline/ap.py wait-health --scope prod
 python3 scripts/autopipeline/ap.py verify-api-docs
 python3 scripts/autopipeline/ap.py check-matrix
 python3 scripts/autopipeline/ap.py gen-summary T0001-1
-python3 scripts/autopipeline/ap.py commit-push T0001-1 --msg "T0001-1: <summary>" --require-matrix
+python3 scripts/autopipeline/ap.py commit-push T0001-1 --msg "T0001-1: <summary>" --require-runtime-health --require-jenkins --require-matrix
 ```
 
 ## Publish (NPM)

package/cli/assets/skill/SKILL.md

@@ -1,15 +1,44 @@
 ---
 name: auto-coding-skill
-description: Use for strict project engineering workflow in Claude/Codex. Initialize docs, fill docs/ENGINEERING.md frontmatter once, then execute design->implement->gates->summary->commit/push.
+description: Use for strict Go fullstack monorepo engineering workflow in Claude/Codex. Initialize docs, fill docs/ENGINEERING.md frontmatter once, then execute design->implement->local-docker-gates->jenkins-trigger->verify.
 ---
 
 # Auto Coding Skill (Claude + Codex)
 
+This branch specializes the skill for Go backend + frontend monorepo projects that build Docker images locally and use Jenkins pipelines to auto-deploy after push. It supports both Claude and Codex. During design, research, implementation, verification, and delivery, prefer already available MCP servers, installed skills, plugins, and app connectors over ad-hoc manual work whenever they can complete the task reliably.
+
+Default to multi-agent execution when the client supports it. Break work into independent design, research, implementation, validation, and documentation subtasks so Claude/Codex can run them in parallel whenever that reduces cycle time without weakening control of the main task.
+
 ## Supported clients
 
 - Claude Code
 - Codex CLI
 
+## Tooling policy
+
+Use available platform capabilities first:
+
+1) Prefer installed MCP servers for design context, documentation lookup, browser automation, issue/docs systems, and deployment/runtime inspection.
+2) Prefer already installed local skills when the task matches them.
+3) Prefer supported plugins/apps/connectors when they provide authoritative project context or can write back records.
+4) Fall back to manual shell/code workflows only when the above are unavailable, insufficient, or slower than direct execution.
+
+Typical examples:
+- Design/UI work: prefer Figma MCP and related design skills.
+- Documentation/library lookup: prefer official docs and MCP-backed doc tools.
+- Project management or knowledge base updates: prefer Linear/Notion connectors if available.
+- Browser/runtime verification: prefer Playwright/browser tools if available.
+- Pipeline and deployment verification: prefer Jenkins-capable connectors, browser automation, or project-integrated tools if available.
+
+## Collaboration policy
+
+Prefer multi-agent mode across the workflow:
+
+1) Split independent subtasks early when they can run in parallel.
+2) Keep the main agent on the critical path: task framing, design decisions, integration, and final quality gates.
+3) Use side agents for bounded work such as research, code slices, documentation updates, regression checks, or review passes.
+4) Do not delegate a blocking architectural decision without keeping one agent responsible for final integration and correctness.
+
 ## Entry
 
 1) Install skill files into target repo:
@@ -40,7 +69,8 @@ Fill only:
 
 This contains all manual fields:
 - `commands.*`
-- `deployment.*`
+- `runtime.*`
+- `jenkins.*`
 - `docs.*`
 
 Do not duplicate config in other md/yaml files.
@@ -51,9 +81,12 @@ Do not duplicate config in other md/yaml files.
 2) `docs/tasks/taskbook.md`
 3) `docs/design/**`
 4) implementation
-5) run gates via `python3 scripts/autopipeline/ap.py`
-6) update API docs + regression matrix + bug list + summary
-7) commit/push
+5) local build/test/lint gates
+6) start and validate local Docker Compose runtime
+7) update API docs + regression matrix + bug list + summary
+8) verify Jenkins config / Jenkinsfile readiness
+9) commit/push to trigger Jenkins
+10) verify Jenkins pipeline + target environment health
 
 ## Commands
 
@@ -61,8 +94,16 @@ Do not duplicate config in other md/yaml files.
 python3 scripts/autopipeline/ap.py run build
 python3 scripts/autopipeline/ap.py run test
 python3 scripts/autopipeline/ap.py run lint
+python3 scripts/autopipeline/ap.py run docker_build
+python3 scripts/autopipeline/ap.py runtime-up
+python3 scripts/autopipeline/ap.py wait-health
+python3 scripts/autopipeline/ap.py run smoke
+python3 scripts/autopipeline/ap.py run regression
+python3 scripts/autopipeline/ap.py runtime-down
+python3 scripts/autopipeline/ap.py verify-jenkins
+python3 scripts/autopipeline/ap.py wait-health --scope prod
 python3 scripts/autopipeline/ap.py verify-api-docs
 python3 scripts/autopipeline/ap.py check-matrix
 python3 scripts/autopipeline/ap.py gen-summary T0001-1
-python3 scripts/autopipeline/ap.py commit-push T0001-1 --msg "T0001-1: <summary>" --require-matrix
+python3 scripts/autopipeline/ap.py commit-push T0001-1 --msg "T0001-1: <summary>" --require-runtime-health --require-jenkins --require-matrix
 ```

package/cli/assets/skill/data/templates/ENGINEERING.md

@@ -2,6 +2,12 @@
 project:
   name: ""
   repo_root: "."
+  stack: "go-fullstack-monorepo"
+  backend_dir: ""
+  frontend_dir: ""
+  go_main: ""
+  dockerfile: ""
+  jenkinsfile: "Jenkinsfile"
 
 commands:
   build: ""
@@ -9,22 +15,33 @@ commands:
   lint: ""
   typecheck: ""
   format: ""
+  docker_build: ""
+  compose_up: ""
+  compose_down: ""
   smoke: ""
   regression: ""
 
-deployment:
-  host: ""
-  ssh_port: 22
-  username: ""
-  password: ""
-  service_name: ""
-  systemd_dir: "/usr/lib/systemd/system"
-  remote_app_root: ""
-  remote_jar_path: ""
-  remote_config_dir: ""
-  remote_bin_dir: ""
+runtime:
+  docker_compose_file: ""
+  docker_service: ""
+  container_name: ""
+  image: ""
+  app_port: ""
   health_base_url: ""
   health_path: ""
+  env_file: ""
+  startup_timeout_sec: 120
+
+jenkins:
+  job_name: ""
+  job_url: ""
+  trigger_branch: ""
+  image_repository: ""
+  image_tag_strategy: ""
+  deploy_env: ""
+  deploy_timeout_sec: 1800
+  prod_health_base_url: ""
+  prod_health_path: ""
 
 docs:
   taskbook: "docs/tasks/taskbook.md"
@@ -40,17 +57,18 @@ docs:
 # docs/ENGINEERING.md — AutoPipeline Gates (Source of Truth)
 
 目标：把一次任务固化为不可跳过的流水线：  
-读任务 → 写DD → 实现 → 本地测试通过 → 静态分析+Review落盘 → 更新API Markdown+接口变更清单 →  
-部署(systemd/jar) → 重启验证 → 按API Markdown全量回归 + 回归矩阵0fail →  
-记录Bug并新增自动化回归 → 任务总结落盘 → commit → push
+读任务 → 写DD → 实现 → 本地构建/测试通过 → 静态分析+Review落盘 → 更新 API Markdown+接口变更清单 →  
+本地 Docker Compose 启动验证 → 本地健康检查 → 对本地环境全量回归 + 回归矩阵 0 fail →  
+记录 Bug 并新增自动化回归 → 任务总结落盘 → commit → push 触发 Jenkins → Jenkins 构建镜像并更新目标环境 →  
+生产健康检查通过
 
-规则：任一步骤失败或缺产物，禁止进入下一步；未 push 视为任务未完成，禁止开始下一个任务/子任务。
+规则：任一步骤失败或缺产物，禁止进入下一步；本地 compose 验证未通过禁止 commit；Jenkins 未成功或生产健康检查未通过，任务不视为完成。
 
 ---
 
 ## 0. 配置填写（必须）
 
-先填写 `docs/ENGINEERING.md` frontmatter 中的所有空值（例如 ip/用户名/密码/服务名/路径/命令）。  
+先填写 `docs/ENGINEERING.md` frontmatter 中的所有空值（例如 Go/前端目录、Docker 文件、Compose 服务、Jenkins Job、健康检查地址、命令）。  
 禁止在其他 md/yaml 重复维护这些配置。
 
 ---
@@ -70,19 +88,53 @@ docs:
 
 ---
 
+## 1.5 工具使用策略（Claude / Codex 专属）
+
+优先使用当前环境已安装、已授权、已可访问的工具能力：
+
+1) MCP servers  
+2) 已安装 skills  
+3) plugins / apps / connectors  
+4) shell / 手工实现
+
+规则：
+- 做设计、查资料、看文档、看页面、查知识库、写回外部系统时，优先调用现有 MCP / skills / plugins / apps。
+- 能用权威工具直接完成时，不重复手写中间数据。
+- 工具不可用、无权限、结果不可靠时，才回退到本地命令或手工处理。
+- 选择工具时优先“已安装且当前项目可直接使用”的能力，而不是重新造流程。
+- 查看 Jenkins、知识库、设计稿、页面、缺陷系统时，优先使用现成的连接器或 MCP，而不是手工拼接上下文。
+
+---
+
+## 1.6 多 Agent 协作策略（Claude / Codex 专属）
+
+整个流程尽可能使用多 agent 模式并行推进。
+
+规则：
+- 任务开始后，优先拆分为可并行的子任务：设计补充、资料检索、实现分块、测试验证、文档回写、review。
+- 主 agent 负责关键路径：任务定义、方案裁决、代码集成、质量门禁、最终交付。
+- 子 agent 负责边界清晰、可独立推进的工作，完成后回收结果给主 agent 集成。
+- 如果某项工作会直接阻塞主路径且难以独立定义，不要机械拆分；由主 agent 保持控制。
+- 能并行就不要串行；能拆独立 write scope 就不要让多个 agent 写同一块内容。
+
+---
+
 ## 2. Gate 流水线（强制、不可跳过）
 
 Gate-1 读任务：只从 taskbook 取范围与验收；缺信息先补 taskbook  
 Gate-2 写DD：无DD禁止写代码；DD必须含 时序图/ER图/接口时序（Mermaid）  
 Gate-3 实现：严格按DD；接口变更必须同步 API Markdown  
-Gate-4 本地CI：必须通过（commands.build / commands.test）  
+Gate-4 本地CI：必须通过（commands.build / commands.test）；Go 后端与前端都必须覆盖  
 Gate-5 静态分析+Review：静态分析通过；docs/reviews/ 生成记录  
 Gate-6 文档：更新 api.md + 追加 api-change-log.md  
-Gate-7 部署：单机 systemd/jar；service目录固定 /usr/lib/systemd/system；失败自动回滚  
-Gate-8 重启+健康：restart后必须健康检查通过  
-Gate-9 全量回归：按 API Markdown 全量回归；回归矩阵全量 PASS（0 fail）；发现问题必须写 bug-list 并新增自动化回归用例  
-Gate-10 任务总结：必须生成 docs/tasks/summaries/<TASK_ID>.md  
-Gate-11 完成：全门禁通过后必须 commit+push
+Gate-7 本地运行：必须用项目 Compose 启动本地 Docker 环境；失败先修复再继续  
+Gate-8 健康检查：本地容器启动后必须健康检查通过  
+Gate-9 全量回归：按 API Markdown 对本地 Compose 环境全量回归；回归矩阵全量 PASS（0 fail）；发现问题必须写 bug-list 并新增自动化回归用例  
+Gate-10 Jenkins 准备：Jenkinsfile、Job 配置、镜像仓库策略必须可用  
+Gate-11 任务总结：必须生成 docs/tasks/summaries/<TASK_ID>.md  
+Gate-12 提交触发：本地门禁全过后才允许 commit+push  
+Gate-13 流水线验证：push 后必须确认 Jenkins 自动构建、镜像发布、目标环境更新成功  
+Gate-14 完成：生产健康检查通过并补齐部署记录后，任务才完成
 
 ---
 

package/cli/assets/skill/data/templates/bridges/CLAUDE.md

@@ -1 +1,4 @@
 Follow docs/ENGINEERING.md strictly. Source of truth: docs/ENGINEERING.md.
+Prefer already available MCP servers, installed skills, plugins, and app connectors during design, research, verification, and documentation workflows.
+Prefer multi-agent mode whenever the task can be split into independent parallel subtasks without weakening integration control.
+For Go monorepo + Jenkins projects, local Docker Compose validation must pass before commit, and push is expected to trigger Jenkins pipeline verification.

package/cli/assets/skill/data/templates/bridges/CODEX.md

@@ -1 +1,4 @@
 Follow docs/ENGINEERING.md strictly. Source of truth: docs/ENGINEERING.md.
+Prefer already available MCP servers, installed skills, plugins, and app connectors during design, research, verification, and documentation workflows.
+Prefer multi-agent mode whenever the task can be split into independent parallel subtasks without weakening integration control.
+For Go monorepo + Jenkins projects, local Docker Compose validation must pass before commit, and push is expected to trigger Jenkins pipeline verification.

package/cli/assets/skill/data/templates/docs/deployment/deploy-records/_TEMPLATE-DEPLOY-RECORD.md

@@ -1,13 +1,28 @@
 # Deploy Record — <Task ID> — YYYY-MM-DD
 
-- Target host:
-- Service name:
-- Artifact (local):
-- Remote jar path:
-- Updated items: jar / config / bin / service
-- Backup files (single latest): *.bak / *.tgz.bak
+## 1. Local Compose Validation
+- Docker compose file:
+- Docker service:
+- Container name:
+- Image/tag:
+- Exposed port:
+- Env file:
+- Local health URL:
 
-## Evidence
-- systemctl status:
+## 2. Jenkins Pipeline
+- Jenkins job name:
+- Jenkins build number:
+- Jenkins build URL:
+- Trigger branch:
+- Trigger commit:
+- Image repository:
+- Published image tag:
+- Deploy environment:
+
+## 3. Evidence
+- docker ps / compose ps:
+- local_health_check:
 - smoke_test:
 - api_regression:
+- jenkins_result:
+- production_health_check:

package/cli/assets/skill/data/templates/docs/deployment/deploy-runbook.md

@@ -1,12 +1,19 @@
-# Deploy Runbook（单机 systemd / jar）
+# Deployment Runbook（本地 Compose 验证 + Jenkins 自动部署）
 
-部署参数统一读取：`docs/ENGINEERING.md` frontmatter
-- deployment.host / deployment.ssh_port / deployment.username / deployment.password
-- deployment.service_name / deployment.systemd_dir
-- deployment.remote_app_root / deployment.remote_jar_path / deployment.remote_config_dir / deployment.remote_bin_dir
-- deployment.health_base_url / deployment.health_path
+统一读取：`docs/ENGINEERING.md` frontmatter
+- `runtime.*`：本地 Compose 启动与健康检查
+- `jenkins.*`：Jenkins Job、镜像仓库、目标环境、生产健康检查
 
-部署后必须：
-- smoke-test
-- api-regression
-- 回归矩阵全量 PASS（0 fail）
+执行顺序：
+1. 本地构建、测试、lint、typecheck 通过
+2. 本地 `docker compose` 启动目标服务
+3. 本地 health / smoke / regression 全部通过
+4. `commit + push`
+5. Jenkins 自动触发，完成镜像构建、镜像推送、目标环境更新
+6. 检查 Jenkins 结果与目标环境健康状态
+
+完成条件：
+- 本地 Compose 验证通过
+- Jenkins Pipeline 成功
+- 目标环境健康检查通过
+- `docs/deployment/deploy-records/<TASK_ID>-YYYYMMDD.md` 证据补齐

package/cli/assets/skill/data/templates/docs/reviews/_TEMPLATE-REVIEW.md

@@ -7,8 +7,10 @@
 - Resolved/Deferred（deferred 必须给出后续任务）：
 
 ## 2. 代码质量
-## 3. 测试质量（含新增回归用例）
-## 4. 接口契约（API Markdown + change-log）
-## 5. 安全与性能
-## 6. 风险与回滚
-## 7. 结论（Pass / Blocked）
+## 3. 本地构建与测试质量（Go 后端 + 前端）
+## 4. 本地 Compose 验证（health / smoke / regression）
+## 5. 接口契约（API Markdown + change-log）
+## 6. Jenkins 准备度（Jenkinsfile / job config / image strategy）
+## 7. 安全与性能
+## 8. 风险与回滚
+## 9. 结论（Pass / Blocked）

package/cli/assets/skill/data/templates/docs/tasks/summaries/_TEMPLATE-TASK-SUMMARY.md

@@ -11,7 +11,7 @@
 - 目标：
 - 验收结论：PASS / FAIL（FAIL 必须说明原因与后续计划）
 
-## 2. 变更概览（代码/配置/部署）
+## 2. 变更概览（代码/配置/本地运行/Jenkins）
 - 关键改动点：
 - 影响模块：
 - 兼容性影响（是否破坏兼容、迁移方案）：
@@ -33,15 +33,17 @@
 - 静态分析：`static`
 - Review 文档：`docs/reviews/<TASK_ID>-<timestamp>.md`
 - API 文档：`docs/interfaces/api.md`
+- Jenkins 配置检查：`Jenkinsfile` + `jenkins.*`
 - 回归矩阵：`docs/testing/regression-matrix.md`（全量 PASS，0 fail）
 
 ## 6. Bug 清单与回归用例
 - 新增/确认的 Bug（写入 `docs/bugs/bug-list.md`）：
 - 新增自动化回归用例（引用回归矩阵ID）：
 
-## 7. 部署记录（如有部署）
-- 部署记录：`docs/deployment/deploy-records/<TASK_ID>-YYYYMMDD.md`
-- systemd/service/config/bin 变更（若有）：
+## 7. 本地运行与 Jenkins 部署记录
+- 本地 Compose 验证：health / smoke / regression 结果
+- Jenkins 部署记录：`docs/deployment/deploy-records/<TASK_ID>-YYYYMMDD.md`
+- Docker compose / image / Jenkins Job 变更（若有）：
 
 ## 8. 风险与回滚
 - 风险：

package/cli/assets/skill/data/templates/docs/tasks/taskbook.md

@@ -2,13 +2,13 @@
 
 规则：
 1) 所有任务都写在本文件（持续续写，不另起任务文件）
-2) 允许拆子任务：每个子任务也必须走全流程（DD→实现→测试→review→接口文档→部署→回归→总结→commit→push）
+2) 允许拆子任务：每个子任务也必须走全流程（DD→实现→测试→review→接口文档→本地 Compose 验证→回归→总结→commit→push→Jenkins 验证）
 3) 每个任务必须有明确验收与证据（日志/报告/文件路径）
 
 ---
 
 ## Task T0001 — <Title>
-- 状态：Planned | Designing | Implementing | Testing | Reviewing | Deploying | Done
+- 状态：Planned | Designing | Implementing | Testing | Reviewing | Runtime Verifying | Pipeline Verifying | Done
 - 范围（In scope）：
 - 非目标（Out of scope）：
 - 验收标准（必须可执行）：
@@ -24,7 +24,8 @@
 - API 文档：`docs/interfaces/api.md`
 - API Change Log：`docs/interfaces/api-change-log.md`
 - 本地CI：粘贴摘要或给出文件路径
-- 部署记录（如部署）：`docs/deployment/deploy-records/T0001-YYYYMMDD.md`
+- 本地 Compose 验证：命令输出或 Review 文档摘要
+- Jenkins 部署记录：`docs/deployment/deploy-records/T0001-YYYYMMDD.md`
 - 回归矩阵：`docs/testing/regression-matrix.md`（全量PASS）
 - Bug清单（如有）：`docs/bugs/bug-list.md`
 - 任务总结（强制）：`docs/tasks/summaries/T0001.md`

package/cli/assets/skill/data/templates/docs/testing/regression-matrix.md

@@ -1,5 +1,5 @@
-# Regression Matrix（回归矩阵：必须全量 PASS，0 fail）
+# Regression Matrix（本地 Compose 环境回归矩阵：必须全量 PASS，0 fail）
 
 | ID | Area | Endpoint/Feature | Test Type | Steps / Command | Expected | Status(PASS/FAIL) | Evidence |
 |---|---|---|---|---|---|---|---|
-| R-001 | API | GET /health | smoke | commands.smoke | 200 OK | PASS | <paste log path> |
+| R-001 | API | GET /health | smoke | commands.smoke | local compose 200 OK | PASS | <paste log path> |

package/cli/assets/skill/scripts/ap.py

@@ -6,16 +6,49 @@ from __future__ import annotations
 
 import argparse
 import datetime as _dt
+import time
 from pathlib import Path
 from typing import Optional, List
 
-from core import APError, ensure_git_repo, copy_tree, run, load_yaml, find_config, run_shell
+from core import APError, ensure_git_repo, copy_tree, run, load_yaml, find_config, run_shell, http_get_status
 
 
 def _skill_root() -> Path:
     return Path(__file__).resolve().parent.parent
 
 
+def _compose_base_args(runtime_cfg: dict) -> List[str]:
+    args = ["docker", "compose"]
+    compose_file = str(runtime_cfg.get("docker_compose_file") or "").strip()
+    env_file = str(runtime_cfg.get("env_file") or "").strip()
+    if compose_file:
+        args.extend(["-f", compose_file])
+    if env_file:
+        args.extend(["--env-file", env_file])
+    return args
+
+
+def _join_url(base: str, path: str) -> str:
+    base = str(base or "").strip().rstrip("/")
+    path = str(path or "").strip()
+    if not base or not path:
+        raise APError("Health URL config incomplete. Fill base url and path in docs/ENGINEERING.md.")
+    if not path.startswith("/"):
+        path = "/" + path
+    return base + path
+
+
+def _run_configured_command(repo: Path, cfg: dict, name: str) -> bool:
+    commands = (cfg.get("commands") or {})
+    command = str(commands.get(name) or "").strip()
+    if not command:
+        return False
+    print(f"[run] {name}: {command}")
+    run_shell(command, cwd=repo)
+    print(f"[run] OK: {name}")
+    return True
+
+
 def cmd_install(args: argparse.Namespace) -> None:
     repo = Path(args.repo).resolve()
     templates = _skill_root() / "data" / "templates"
@@ -41,7 +74,7 @@ def cmd_install(args: argparse.Namespace) -> None:
         gi.write_text(secret_line + "\n", encoding="utf-8")
 
     print(f"[install] OK: scaffold installed into {repo}")
-    print("[install] Next: edit docs/ENGINEERING.md frontmatter and fill all project/env fields")
+    print("[install] Next: edit docs/ENGINEERING.md frontmatter and fill project/runtime/jenkins fields")
 
 
 def _infer_title(taskbook: Path, task_id: str) -> str:
@@ -92,7 +125,7 @@ def cmd_gen_summary(args: argparse.Namespace) -> None:
 - 目标：TODO
 - 验收结论：PASS / FAIL — TODO
 
-## 2. 变更概览（代码/配置/部署）
+## 2. 变更概览（代码/配置/本地运行/Jenkins）
 ### Git change snapshot
 - Staged files:
 {('- ' + staged.replace('\n','\n- ')) if staged else '- (none)'}
@@ -111,7 +144,12 @@ def cmd_gen_summary(args: argparse.Namespace) -> None:
 - 静态分析：TODO
 - Review 文档：TODO
 - DD 文档：TODO
+- Jenkins 准备：TODO
 - 回归矩阵：`{regression_matrix}`（全量 PASS，0 fail）
+
+## 6. 本地运行与 Jenkins 部署记录
+- Local compose：TODO
+- Jenkins build / deploy：TODO
 """
 
     out_file.write_text(content, encoding="utf-8")
@@ -162,8 +200,7 @@ def _load_cfg(repo: Path) -> dict:
 
 def cmd_run(args: argparse.Namespace) -> None:
     """
-    Run a configured gate command:
-      build | test | lint | typecheck | format | smoke | regression
+    Run any configured gate command by name.
     Commands are read from docs/ENGINEERING.md frontmatter.
     """
     repo = Path(args.repo).resolve()
@@ -182,6 +219,89 @@ def cmd_run(args: argparse.Namespace) -> None:
     print(f"[run] OK: {name}")
 
 
+def cmd_runtime_up(args: argparse.Namespace) -> None:
+    repo = Path(args.repo).resolve()
+    cfg = _load_cfg(repo)
+    runtime_cfg = (cfg.get("runtime") or {})
+    if _run_configured_command(repo, cfg, "compose_up"):
+        return
+    compose_args = _compose_base_args(runtime_cfg) + ["up", "-d"]
+    docker_service = str(runtime_cfg.get("docker_service") or "").strip()
+    if docker_service:
+        compose_args.append(docker_service)
+    print(f"[runtime-up] {' '.join(compose_args)}")
+    run(compose_args, cwd=repo)
+    print("[runtime-up] OK")
+
+
+def cmd_runtime_down(args: argparse.Namespace) -> None:
+    repo = Path(args.repo).resolve()
+    cfg = _load_cfg(repo)
+    runtime_cfg = (cfg.get("runtime") or {})
+    if _run_configured_command(repo, cfg, "compose_down"):
+        return
+    compose_args = _compose_base_args(runtime_cfg) + ["down", "--remove-orphans"]
+    print(f"[runtime-down] {' '.join(compose_args)}")
+    run(compose_args, cwd=repo)
+    print("[runtime-down] OK")
+
+
+def cmd_wait_health(args: argparse.Namespace) -> None:
+    repo = Path(args.repo).resolve()
+    cfg = _load_cfg(repo)
+    scope = args.scope
+    if scope == "runtime":
+        runtime_cfg = (cfg.get("runtime") or {})
+        url = _join_url(str(runtime_cfg.get("health_base_url") or ""), str(runtime_cfg.get("health_path") or ""))
+        timeout_s = int(runtime_cfg.get("startup_timeout_sec") or 120)
+    else:
+        jenkins_cfg = (cfg.get("jenkins") or {})
+        url = _join_url(
+            str(jenkins_cfg.get("prod_health_base_url") or ""),
+            str(jenkins_cfg.get("prod_health_path") or "")
+        )
+        timeout_s = int(jenkins_cfg.get("deploy_timeout_sec") or 1800)
+
+    deadline = time.time() + timeout_s
+    last_error = "(none)"
+    while time.time() < deadline:
+        try:
+            status = http_get_status(url, timeout_s=5)
+            last_error = f"HTTP {status}"
+            if 200 <= status < 400:
+                print(f"[wait-health] OK: {scope} {url} -> {status}")
+                return
+        except Exception as exc:  # pragma: no cover - depends on runtime env
+            last_error = str(exc)
+        time.sleep(2)
+    raise APError(f"Health check timeout for {scope}: {url}\nLast result: {last_error}")
+
+
+def cmd_verify_jenkins(args: argparse.Namespace) -> None:
+    repo = Path(args.repo).resolve()
+    cfg = _load_cfg(repo)
+    project_cfg = (cfg.get("project") or {})
+    jenkins_cfg = (cfg.get("jenkins") or {})
+    jenkinsfile = Path(repo, str(project_cfg.get("jenkinsfile") or "Jenkinsfile"))
+    if not jenkinsfile.exists():
+        raise APError(f"Jenkinsfile not found: {jenkinsfile}")
+
+    required = [
+        ("jenkins.job_name", jenkins_cfg.get("job_name")),
+        ("jenkins.job_url", jenkins_cfg.get("job_url")),
+        ("jenkins.trigger_branch", jenkins_cfg.get("trigger_branch")),
+        ("jenkins.image_repository", jenkins_cfg.get("image_repository")),
+        ("jenkins.image_tag_strategy", jenkins_cfg.get("image_tag_strategy")),
+        ("jenkins.deploy_env", jenkins_cfg.get("deploy_env")),
+        ("jenkins.prod_health_base_url", jenkins_cfg.get("prod_health_base_url")),
+        ("jenkins.prod_health_path", jenkins_cfg.get("prod_health_path")),
+    ]
+    missing = [name for name, value in required if not str(value or "").strip()]
+    if missing:
+        raise APError("Missing Jenkins config: " + ", ".join(missing))
+    print(f"[verify-jenkins] OK: {jenkinsfile}")
+
+
 def cmd_verify_api_docs(args: argparse.Namespace) -> None:
     """Ensure API markdown doc and change-log exist."""
     repo = Path(args.repo).resolve()
@@ -212,6 +332,12 @@ def cmd_commit_push(args: argparse.Namespace) -> None:
             f"Generate: python3 scripts/autopipeline/ap.py gen-summary {task_id}"
         )
 
+    if args.require_runtime_health:
+        cmd_wait_health(argparse.Namespace(repo=str(repo), scope="runtime"))
+
+    if args.require_jenkins:
+        cmd_verify_jenkins(argparse.Namespace(repo=str(repo)))
+
     if args.require_matrix:
         cmd_check_matrix(argparse.Namespace(repo=str(repo)))
 
@@ -222,7 +348,7 @@ def cmd_commit_push(args: argparse.Namespace) -> None:
 
     run(["git", "commit", "-m", msg], cwd=repo)
     run(["git", "push"], cwd=repo)
-    print("[commit-push] OK")
+    print("[commit-push] OK - push completed, Jenkins should auto-trigger")
 
 
 def main(argv: Optional[List[str]] = None) -> int:
@@ -246,12 +372,27 @@ def main(argv: Optional[List[str]] = None) -> int:
     s.add_argument("name")
     s.set_defaults(func=cmd_run)
 
+    s = sp.add_parser("runtime-up")
+    s.set_defaults(func=cmd_runtime_up)
+
+    s = sp.add_parser("runtime-down")
+    s.set_defaults(func=cmd_runtime_down)
+
+    s = sp.add_parser("wait-health")
+    s.add_argument("--scope", choices=["runtime", "prod"], default="runtime")
+    s.set_defaults(func=cmd_wait_health)
+
+    s = sp.add_parser("verify-jenkins")
+    s.set_defaults(func=cmd_verify_jenkins)
+
     s = sp.add_parser("verify-api-docs")
     s.set_defaults(func=cmd_verify_api_docs)
 
     s = sp.add_parser("commit-push")
     s.add_argument("task_id")
     s.add_argument("--msg", required=True)
+    s.add_argument("--require-runtime-health", action="store_true")
+    s.add_argument("--require-jenkins", action="store_true")
     s.add_argument("--require-matrix", action="store_true")
     s.set_defaults(func=cmd_commit_push)
 

package/cli/assets/skill/scripts/core.py

@@ -104,7 +104,7 @@ def find_config(repo: Path) -> Path:
             return c
     raise APError(
         "Project config not found. Create docs/ENGINEERING.md "
-        "and put commands + deployment fields in YAML frontmatter."
+        "and put commands + runtime + jenkins fields in YAML frontmatter."
     )
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvis1513/auto-coding-skill",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "CLI installer for auto-coding-skill (Claude Code + Codex CLI).",
   "type": "module",
   "bin": {
@@ -29,7 +29,8 @@
     "engineering",
     "workflow",
     "ci",
-    "deployment"
+    "docker",
+    "local-testing"
   ],
   "repository": {
     "type": "git",