@ccoalm/ccl-skills 0.1.0

package/dist/assets/marketplace/plugins/ccl-skills/skills/test-artifact-management/references/ci_templates/README.md

@@ -0,0 +1,120 @@
+# CI Integration Templates
+
+Templates for running tests, syncing Bitable, publishing the Feishu report,
+and posting a PR/MR comment with the regression delta.
+
+| File | Use when |
+|---|---|
+| `github-actions.yml` | GitHub repo |
+| `gitlab-ci.yml` | GitLab repo |
+| `jenkins.Jenkinsfile` | Jenkins pipeline |
+
+## What each does
+
+1. **Stack setup** — keep or add the runtime setup required by the unit
+2. **lark-cli auth** — initializes the Feishu bot identity from CI secrets
+3. **Restore `last-run.json`** — cache key per branch+unit so vs-last-run diff
+   survives across runs
+4. **`make report-run`** — runs tests, writes JUnit + sidecar, syncs Bitable,
+   publishes / updates the Feishu report doc (exits non-zero on failure)
+5. **PR/MR comment — runs even when tests fail** — pipes `--pr-summary --fail-on=never`
+   to the platform comment API; shows overview line +
+   🔴 new failures + 🟢 fixed. Uses `if: always()` (GitHub) / `after_script`
+   (GitLab) / `post { always {} }` (Jenkins) so red CI still gets the summary
+   posted when developers need it most.
+6. **Artifact upload** — `test/results/` for debugging (7-day retention)
+7. **`TC_SIDECAR_STRICT=1`** is exported in every template — sidecar write
+   failures fail the test (instead of silently leaving Bitable stale).
+
+## Adapting to your project
+
+1. Pick the template matching your CI
+2. Replace every `<unit>` placeholder with your deployable-unit directory
+   (e.g. `web`, `app`, `services/auth`)
+3. Add CI secrets:
+   - `LARK_BOT_APP_ID`
+   - `LARK_BOT_APP_SECRET`
+4. Keep or add the stack setup that matches your unit; remove unrelated setup
+5. Adjust `path:` filters so the workflow only runs when this unit's files change
+
+These are CI-provider scaffolds, not per-stack test adapters. They do not create
+the project's test command, JUnit reporter, or TC sidecar wiring. Before use,
+make `make report-run` produce the configured JUnit XML and `tc-map.jsonl` for
+the target stack. The bundled TC helpers cover Python, Go, TypeScript, and
+Dart/Flutter; other stacks need an equivalent sidecar integration. Vite/vitest
+also needs its repository's actual test command and JUnit flags rather than the
+Node placeholder in a template.
+
+## Multi-unit monorepo
+
+Each unit gets **one workflow file** (`test-web.yml`, `test-app.yml`,
+`test-svc-auth.yml`, ...). Do **not** unify into one mega-workflow — the whole
+point of deployable-unit scope is independent failure / report / cadence.
+
+GitHub example structure:
+
+```
+.github/workflows/
+├── test-web.yml          # path: web/**
+├── test-app.yml          # path: app/**
+└── test-svc-auth.yml     # path: services/auth/**
+```
+
+A PR that only touches `web/` triggers only `test-web.yml`; its PR comment is
+the web unit's report. Other units stay quiet.
+
+## `--pr-summary` output format
+
+The `--pr-summary` flag emits short Markdown suitable for a PR/MR comment:
+
+```
+### 🧪 自动化测试结果
+
+通过 **45** / 总 **48** · ❌ 失败 **2** · ⚠ 阻塞 **1** · 📊 覆盖率 82.3% (412/501)
+
+**🔴 本次新增失败 / 阻塞（2）**：
+
+- `TC-SY-005`
+- `TC-AU-003`
+```
+
+Always under ~30 lines (long ID lists truncated to 20/10 with "另外 N 个").
+Safe to paste verbatim into a PR comment.
+
+## Last-run snapshot persistence
+
+The `test/results/last-run.json` snapshot drives the vs-last-run diff. Without
+CI caching, it would reset on every fresh runner. Cache keys include the unique
+run/pipeline id so each run produces a NEW cache entry (otherwise an exact-key
+hit prevents the cache from being re-saved). Fallback keys pull the most recent
+prior snapshot.
+
+- **GitHub Actions**: `actions/cache@v4` with `key: tc-last-run-<unit>-<branch>-<run_id>`
+  and `restore-keys` falling back to branch then main
+- **GitLab CI**: stable branch/unit cache keys with a default-branch fallback
+- **Jenkins**: `copyArtifacts` from `lastSuccessful()` build of the same job
+
+If the cache is cold (first run on a branch), the report shows no
+vs-last-run section — correct behavior, not an error.
+
+## Concurrent runs
+
+`gen_report.py` reads Bitable, mutates in memory, writes back — there is **no
+CAS / ETag**. Two simultaneous runs writing to the same unit's Bitable can
+overwrite each other's status / 信息流转 entries. The templates serialize
+same-(unit, branch) runs:
+
+- **GitHub Actions**: `concurrency: { group: tc-report-<unit>-${{ github.ref }}, cancel-in-progress: false }`
+- **GitLab CI**: `resource_group: "tc-report-<unit>-${ref_slug}"`
+
+A failed run inside the serialized group still releases the lock, so retries
+proceed cleanly. Cross-branch parallelism is intentionally allowed (each
+branch's results are independent).
+
+## Secret handling
+
+Bot secrets are piped to `lark-cli config init --app-secret-stdin` via
+`printf '%s' "$SECRET" | …` — they never appear in process argv, so `ps aux`
+on a shared runner does not leak them. Resource IDs (base_token, table_id,
+report_doc_url) live in the committed `test/.report-config.json` and are not
+secrets.

package/dist/assets/marketplace/plugins/ccl-skills/skills/test-artifact-management/references/ci_templates/github-actions.yml

@@ -0,0 +1,119 @@
+# GitHub Actions template — run tests, publish Feishu report, comment on PR.
+#
+# Replace <unit> placeholders with your deployable-unit directory (e.g. "web",
+# "app", "services/auth"). Copy this into .github/workflows/test-<unit>.yml.
+#
+# Required repository secrets:
+#   LARK_BOT_APP_ID      — Feishu bot app id (for lark-cli --as bot)
+#   LARK_BOT_APP_SECRET  — Feishu bot app secret  (piped via stdin, NEVER in argv)
+#
+# Already committed in <unit>/test/.report-config.json (resource IDs, not secrets):
+#   base_token, table_id, folder_token (optional), report_doc_url
+
+name: Test (<unit>)
+
+on:
+  pull_request:
+    paths:
+      - '<unit>/**'
+      - '.github/workflows/test-<unit>.yml'
+  push:
+    branches: [main]
+    paths:
+      - '<unit>/**'
+
+# Serialize same-unit runs to avoid concurrent Bitable writes losing each other
+# (gen_report.py has no CAS; last-write-wins).
+concurrency:
+  group: tc-report-<unit>-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  pull-requests: write   # required for gh pr comment
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: <unit>
+    steps:
+      - uses: actions/checkout@v4
+
+      # ── Stack setup (pick one; remove the rest) ─────────────────────────
+      - uses: actions/setup-node@v4    # Vitest / Jest
+        with: { node-version: '20' }
+      # - uses: actions/setup-python@v5
+      #   with: { python-version: '3.12' }
+      # - uses: actions/setup-go@v5
+      #   with: { go-version: '1.22' }
+
+      - name: Install lark-cli + auth (stdin, no argv exposure)
+        env:
+          LARK_BOT_APP_ID: ${{ secrets.LARK_BOT_APP_ID }}
+          LARK_BOT_APP_SECRET: ${{ secrets.LARK_BOT_APP_SECRET }}
+        run: |
+          npm i -g @larksuiteoapi/lark-cli  # adjust to your distribution channel
+          # Pipe the secret via stdin; --app-secret-stdin keeps it OUT of ps/argv.
+          printf '%s' "$LARK_BOT_APP_SECRET" | \
+            lark-cli config init \
+              --app-id "$LARK_BOT_APP_ID" \
+              --app-secret-stdin \
+              --brand feishu
+
+      # Cache key includes run_id so each run produces a NEW cache entry that
+      # actions/cache will save (otherwise an exact-key hit prevents the save).
+      # restore-keys falls back to the most recent prior cache for this branch,
+      # then to main.
+      - name: Restore last-run snapshot (for vs-last-run diff)
+        uses: actions/cache@v4
+        with:
+          path: <unit>/test/results/last-run.json
+          key: tc-last-run-<unit>-${{ github.ref_name }}-${{ github.run_id }}
+          restore-keys: |
+            tc-last-run-<unit>-${{ github.ref_name }}-
+            tc-last-run-<unit>-main-
+
+      - name: Install dependencies
+        run: npm ci      # or: uv pip install -e . / go mod download
+
+      - name: Run tests + sync Bitable + publish Feishu report
+        id: report_run
+        run: make report-run
+        env:
+          # bot identity is auto-detected by gen_report.py when CI=true
+          CI: 'true'
+          # Sidecar write failures should fail tests (no silent Bitable staleness).
+          TC_SIDECAR_STRICT: '1'
+
+      # IMPORTANT: run even when report_run failed — that's when the summary
+      # matters most. fail-soft (continue-on-error + || true) so missing
+      # python / config / helper doesn't fail the job AFTER red tests.
+      # Write under the unit working-dir so hashFiles() (workspace-relative)
+      # can see the artifact in the next step.
+      - name: Build PR comment summary
+        if: always() && github.event_name == 'pull_request'
+        continue-on-error: true
+        run: |
+          set +e
+          python test/scripts/gen_report.py \
+            --config test/.report-config.json \
+            --pr-summary --fail-on=never > pr-summary.md 2>pr-summary.err || true
+
+      - name: Post PR comment
+        if: always() && github.event_name == 'pull_request' && hashFiles('<unit>/pr-summary.md') != ''
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr comment "${{ github.event.pull_request.number }}" \
+            --body-file pr-summary.md || true
+
+      - name: Upload JUnit + sidecar (for debugging)
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results-<unit>
+          path: <unit>/test/results/
+          retention-days: 7

package/dist/assets/marketplace/plugins/ccl-skills/skills/test-artifact-management/references/ci_templates/gitlab-ci.yml

@@ -0,0 +1,76 @@
+# GitLab CI template — run tests, sync Bitable, publish Feishu report, comment on MR.
+#
+# Replace <unit> placeholders with your deployable-unit directory. Add this file
+# to the repository pipeline configuration or include it from that configuration.
+#
+# Required CI/CD variables:
+#   LARK_BOT_APP_ID
+#   LARK_BOT_APP_SECRET
+#   GITLAB_API_TOKEN
+
+variables:
+  UNIT: "<unit>"
+  TC_GEN_REPORT: "test/scripts/gen_report.py"
+
+.tc_report_template:
+  image: node:20
+  stage: test
+  resource_group: "tc-report-${UNIT}-${CI_COMMIT_REF_SLUG}"
+  cache:
+    - key: "tc-last-run-${UNIT}-${CI_COMMIT_REF_SLUG}"
+      paths:
+        - "${UNIT}/test/results/last-run.json"
+      fallback_keys:
+        - "tc-last-run-${UNIT}-${CI_DEFAULT_BRANCH}"
+  before_script:
+    - npm i -g @larksuiteoapi/lark-cli
+    - printf '%s' "$LARK_BOT_APP_SECRET" |
+        lark-cli config init
+          --app-id "$LARK_BOT_APP_ID"
+          --app-secret-stdin
+          --brand feishu
+  variables:
+    TC_SIDECAR_STRICT: "1"
+  script:
+    - cd "$UNIT"
+    - npm ci
+    - make report-run
+  after_script:
+    - |
+      set +e
+      [ -z "$CI_MERGE_REQUEST_IID" ] && exit 0
+      for tool in python curl jq; do
+        if ! command -v "$tool" >/dev/null 2>&1; then
+          echo "after_script: $tool missing — skipping MR comment" >&2
+          exit 0
+        fi
+      done
+      cd "$UNIT" 2>/dev/null || exit 0
+      python "$CI_PROJECT_DIR/$TC_GEN_REPORT" \
+        --config test/.report-config.json --pr-summary --fail-on=never \
+        > /tmp/mr-summary.md 2>/tmp/mr-summary.err
+      [ -s /tmp/mr-summary.md ] || exit 0
+      curl --silent --max-time 30 --connect-timeout 10 --request POST \
+        --header "PRIVATE-TOKEN: $GITLAB_API_TOKEN" \
+        --header "Content-Type: application/json" \
+        --data "$(jq -Rn --rawfile body /tmp/mr-summary.md '{body:$body}')" \
+        "$CI_API_V4_URL/projects/$CI_PROJECT_ID/merge_requests/$CI_MERGE_REQUEST_IID/notes" \
+        > /dev/null || echo "after_script: MR comment failed" >&2
+      exit 0
+  artifacts:
+    when: always
+    paths:
+      - "${UNIT}/test/results/"
+    expire_in: 7 days
+    reports:
+      junit: "${UNIT}/test/results/*.xml"
+
+test-<unit>:
+  extends: .tc_report_template
+  variables:
+    UNIT: "<unit>"
+  rules:
+    - if: $CI_PIPELINE_SOURCE == 'merge_request_event'
+      changes: ['<unit>/**/*']
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+      changes: ['<unit>/**/*']

package/dist/assets/marketplace/plugins/ccl-skills/skills/test-artifact-management/references/ci_templates/jenkins.Jenkinsfile

@@ -0,0 +1,106 @@
+// Jenkins declarative pipeline — run tests, publish Feishu report, comment on PR.
+//
+// Replace <unit> placeholders with your deployable-unit directory.
+//
+// Required Jenkins credentials (Manage Jenkins → Credentials):
+//   lark-bot-app-id        (Secret Text)
+//   lark-bot-app-secret    (Secret Text)
+//   github-token           (Secret Text, repo:status + pull_requests:write)
+//
+// Committed in <unit>/test/.report-config.json: base_token, table_id, report_doc_url
+//
+// Requires plugins: github-pullrequest (or similar for PR detection),
+// Pipeline: Stage View, Credentials Binding.
+
+pipeline {
+  agent any
+
+  environment {
+    UNIT = '<unit>'
+    LAST_RUN_FILE = "${WORKSPACE}/${UNIT}/test/results/last-run.json"
+  }
+
+  stages {
+    stage('Setup') {
+      steps {
+        dir("${UNIT}") {
+          // Install lark-cli
+          withCredentials([
+            string(credentialsId: 'lark-bot-app-id', variable: 'LARK_BOT_APP_ID'),
+            string(credentialsId: 'lark-bot-app-secret', variable: 'LARK_BOT_APP_SECRET'),
+          ]) {
+            sh '''
+              npm i -g @larksuiteoapi/lark-cli
+              # Pipe secret via stdin so it never appears in ps/argv.
+              printf '%s' "$LARK_BOT_APP_SECRET" | \
+                lark-cli config init \
+                  --app-id "$LARK_BOT_APP_ID" \
+                  --app-secret-stdin \
+                  --brand feishu
+            '''
+          }
+        }
+      }
+    }
+
+    stage('Restore last-run snapshot') {
+      steps {
+        // Use Jenkins Artifact Manager or external storage to persist last-run.json
+        // across builds. Simplest: copyArtifacts from the last successful build.
+        script {
+          try {
+            copyArtifacts(
+              projectName: env.JOB_NAME,
+              filter: "${UNIT}/test/results/last-run.json",
+              selector: lastSuccessful(),
+              optional: true
+            )
+          } catch (Exception e) {
+            echo "No prior snapshot — first run for this branch."
+          }
+        }
+      }
+    }
+
+    stage('Test + Report') {
+      steps {
+        dir("${UNIT}") {
+          // TC_SIDECAR_STRICT=1 makes sidecar write failures fail tests
+          // (no silent Bitable staleness when CI passes).
+          sh '''
+            export TC_SIDECAR_STRICT=1
+            npm ci
+            make report-run
+          '''
+        }
+      }
+    }
+    // Note: PR comment is moved to post{always{}} below — it MUST land even
+    // on red builds, which is when the regression summary is most useful.
+  }
+
+  post {
+    // Runs on every build (success or failure). PR comment FIRST — that's
+    // the most useful signal for devs when the build is red.
+    always {
+      script {
+        if (env.CHANGE_ID) {
+          dir("${UNIT}") {
+            withCredentials([string(credentialsId: 'github-token', variable: 'GH_TOKEN')]) {
+              sh '''
+                python test/scripts/gen_report.py \
+                  --config test/.report-config.json --pr-summary --fail-on=never > /tmp/pr-summary.md || true
+                if [ -s /tmp/pr-summary.md ]; then
+                  gh pr comment "${CHANGE_ID}" --body-file /tmp/pr-summary.md \
+                    --repo "${CHANGE_URL%/pull/*}" || true
+                fi
+              '''
+            }
+          }
+        }
+      }
+      archiveArtifacts artifacts: "${UNIT}/test/results/**", allowEmptyArchive: true
+      junit testResults: "${UNIT}/test/results/*.xml", allowEmptyResults: true
+    }
+  }
+}