{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Create a workflow with a build job and a deploy job that depends on it, passing a version between them."}, {"role": "assistant", "content": "```yaml\nname: Build and Deploy\n\non:\n  push:\n    tags: ['v*']\n\npermissions:\n  contents: read\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n    outputs:\n      version: ${{ steps.set-version.outputs.version }}\n      artifact: ${{ steps.build.outputs.artifact }}\n    steps:\n      - uses: actions/checkout@v4\n      - id: set-version\n        run: echo \"version=${GITHUB_REF_NAME#v}\" >> \"$GITHUB_OUTPUT\"\n      - id: build\n        run: |\n          mkdir -p dist\n          echo \"built-${{ steps.set-version.outputs.version }}\" > dist/version.txt\n          echo \"artifact=dist\" >> \"$GITHUB_OUTPUT\"\n      - uses: actions/upload-artifact@v4\n        with:\n          name: dist\n          path: dist/\n\n  deploy:\n    needs: build\n    runs-on: ubuntu-latest\n    environment: production\n    steps:\n      - uses: actions/download-artifact@v4\n        with:\n          name: dist\n          path: dist/\n      - name: Deploy\n        run: |\n          echo \"Deploying version ${{ needs.build.outputs.version }}\"\n          ls -la dist/\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What expressions and contexts are available?"}, {"role": "assistant", "content": "Expressions use `${{ ... }}` and evaluate before the step runs. Key contexts: `github` (event, ref, repo, actor, workflow), `secrets`, `env`, `inputs`, `needs` (previous job outputs), `strategy` (matrix values), `runner` (OS, temp dir), `vars` (repository/org variables). Example conditions: ```yaml\nif: github.event_name == 'pull_request'\nif: failure()\nif: always()\nif: contains(github.event.pull_request.labels.*.name, 'deploy')\n```\nUse `env:` at workflow/job/step level for values and reference them with `${{ env.NAME }}`."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I build and push a Docker image?"}, {"role": "assistant", "content": "Use docker/setup-buildx + docker/login-action + docker/build-push-action: ```yaml\n- uses: docker/setup-buildx-action@v3\n- uses: docker/login-action@v3\n  with:\n    registry: ghcr.io\n    username: ${{ github.actor }}\n    password: ${{ secrets.GITHUB_TOKEN }}\n- uses: docker/build-push-action@v6\n  with:\n    push: true\n    tags: ghcr.io/${{ github.repository }}:${{ github.sha }}\n```\nPermissions needed: `packages: write` for GHCR."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Create a workflow that posts a Slack notification when CI fails on the default branch."}, {"role": "assistant", "content": "```yaml\nname: CI\n\non:\n  push:\n    branches: [main]\n  pull_request:\n\njobs:\n  test:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: pip install -e .[test]\n      - run: pytest -v\n\n  notify:\n    needs: test\n    if: failure() && github.ref == 'refs/heads/main'\n    runs-on: ubuntu-latest\n    steps:\n      - uses: rtCamp/action-slack-notify@v2\n        env:\n          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}\n          SLACK_TITLE: CI failed on main\n          SLACK_MESSAGE: 'Run: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is GITHUB_TOKEN and what can it do?"}, {"role": "assistant", "content": "`GITHUB_TOKEN` is an automatically created, per-run secret that authenticates as the `github-actions` bot. It works with `gh` CLI and the REST/GraphQL APIs inside a workflow without storing a PAT. Its permissions are controlled by the `permissions:` block; for new repositories the default is read-only for `contents` unless configured. Example: ```yaml\npermissions:\n  contents: read\n  pull-requests: write\n```\nTo publish releases you need `permissions: contents: write`."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I restrict which paths trigger a workflow?"}, {"role": "assistant", "content": "Use path filters on push and pull_request: ```yaml\non:\n  push:\n    paths:\n      - 'src/**'\n      - '!docs/**'\n```\nThis only runs when files under `src/` change and ignores docs-only changes. Path filters do NOT work with `pull_request_target`. For skipping a job instead of the whole workflow, use `paths-ignore` or a `dorny/paths-filter@v3` action on changed files."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What does the concurrency key do?"}, {"role": "assistant", "content": "`concurrency` cancels or queues overlapping runs so the same workflow does not race itself: ```yaml\nconcurrency:\n  group: ${{ github.workflow }}-${{ github.ref }}\n  cancel-in-progress: true\n```\nGrouping by `github.ref` means each branch/PR has its own queue, and `cancel-in-progress: true` kills the older run when a new one starts. For deployments, group by environment instead of ref so two branches never deploy simultaneously."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is the default working directory in a job?"}, {"role": "assistant", "content": "Steps run in `$GITHUB_WORKSPACE` — the checked-out repository root — and the runner's `$HOME` is separate. `actions/checkout@v4` populates the workspace by default. Override per step with `working-directory:` or globally with `defaults.run.working-directory:`. Use `$RUNNER_TEMP` for temporary files, not the workspace."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Create a workflow that caches pip dependencies to speed up installs."}, {"role": "assistant", "content": "```yaml\nname: CI\n\non:\n  push:\n    branches: [main]\n  pull_request:\n\njobs:\n  test:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n          cache: pip\n          cache-dependency-path: '**/requirements*.txt'\n      - run: pip install -r requirements.txt -r requirements-dev.txt\n      - run: pytest -v\n```\n\nIf you need more control, `actions/cache@v4` with an explicit `key` and `restore-keys` works too, but `cache: pip` on setup-python is simpler and usually enough."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I trigger a workflow on a pull request?"}, {"role": "assistant", "content": "Add the `pull_request` event to the `on` key, optionally scoped to branches: ```yaml\non:\n  pull_request:\n    branches: [main]\n```\nThis runs on opened, synchronize (new commits), and reopened PRs. Use `pull_request_target` only when you need to run with the base branch's secrets (it is dangerous because it executes untrusted PR code — avoid unless you understand the risk)."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Give me a Node.js CI workflow that installs dependencies, runs tests and builds."}, {"role": "assistant", "content": "```yaml\nname: Node CI\n\non:\n  push:\n    branches: [main]\n  pull_request:\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-node@v4\n        with:\n          node-version: 20\n          cache: npm\n      - run: npm ci\n      - run: npm test\n      - run: npm run build\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Create a workflow that runs a nightly dependency audit using pip-audit."}, {"role": "assistant", "content": "```yaml\nname: Nightly Dependency Audit\n\non:\n  schedule:\n    - cron: '0 3 * * *'\n  workflow_dispatch:\n\npermissions:\n  contents: read\n\njobs:\n  audit:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: python -m pip install --upgrade pip-audit\n      - name: Audit dependencies\n        run: pip-audit -r requirements.txt\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a manual workflow with inputs to choose the environment and a version to deploy."}, {"role": "assistant", "content": "```yaml\nname: Manual Deploy\n\non:\n  workflow_dispatch:\n    inputs:\n      environment:\n        description: 'Target environment'\n        required: true\n        type: choice\n        options:\n          - staging\n          - production\n      version:\n        description: 'Version to deploy (e.g. 1.4.2)'\n        required: true\n        type: string\n\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    environment: ${{ inputs.environment }}\n    steps:\n      - uses: actions/checkout@v4\n      - name: Deploy version\n        run: |\n          echo \"Deploying ${{ inputs.version }} to ${{ inputs.environment }}\"\n          ./scripts/deploy.sh \"${{ inputs.version }}\"\n        env:\n          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow that enforces formatting with pre-commit on every pull request."}, {"role": "assistant", "content": "```yaml\nname: Pre-commit\n\non:\n  pull_request:\n\npermissions:\n  contents: read\n\njobs:\n  pre-commit:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: python -m pip install pre-commit\n      - run: pre-commit run --all-files\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is a matrix build?"}, {"role": "assistant", "content": "A matrix runs a job across combinations of values: ```yaml\nstrategy:\n  matrix:\n    os: [ubuntu-latest, windows-latest]\n    python-version: ['3.11', '3.12']\n```\nEach combination runs as a separate job; reference the values with `${{ matrix.os }}` and `${{ matrix.python-version }}`. You can exclude combos with `exclude:`, include extras with `include:`, and fail the whole matrix fast with `fail-fast: false` when you want every combo to finish even if one fails."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Explain this GitHub Actions workflow:\n```yaml\nname: CI\non:\n  push:\n    branches: [main]\n  pull_request:\njobs:\n  test:\n    runs-on: ubuntu-latest\n    strategy:\n      matrix:\n        python-version: ['3.11', '3.12']\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: ${{ matrix.python-version }}\n      - run: pip install -e .\n      - run: pytest\n```"}, {"role": "assistant", "content": "This is a standard Python CI workflow. `on: push` to `main` plus any `pull_request` means it runs on both main commits and PR updates. The `test` job uses `ubuntu-latest`, and the matrix runs two parallel jobs for Python 3.11 and 3.12. Each job checks out the code (`actions/checkout@v4`), sets up the matrix Python version, installs the package editable, then runs pytest. Because `on:` has no `paths:` filter, it runs on every commit/PR — consider adding one if the repo is large."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I set up Node.js in a workflow?"}, {"role": "assistant", "content": "```yaml\n- uses: actions/setup-node@v4\n  with:\n    node-version: 20\n    cache: npm\n    cache-dependency-path: package-lock.json\n```\n`cache: npm` caches `~/.npm`. For pnpm use `cache: pnpm` and run `pnpm install --frozen-lockfile`; for yarn use `cache: yarn`."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow to run Sphinx docs build and fail if there are warnings."}, {"role": "assistant", "content": "```yaml\nname: Docs\n\non:\n  push:\n    paths: ['docs/**']\n  pull_request:\n    paths: ['docs/**']\n\njobs:\n  docs:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: pip install -e .[docs]\n      - run: sphinx-build -W -b html docs docs/_build/html\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How should I structure a CI workflow to keep it fast?"}, {"role": "assistant", "content": "1) Split jobs so unrelated checks run in parallel. 2) Use path filters to skip jobs that don't apply (`paths:` on the event, or `dorny/paths-filter`). 3) Cache dependencies (`cache: pip` / `cache: npm` / `actions/cache`). 4) Use `fail-fast: false` only when you need full matrix results; otherwise keep it on. 5) Prefer fewer, larger runners for heavy builds (`ubuntu-latest-4-core`). 6) Don't rebuild what a reusable workflow already built — pass artifacts. 7) Put linting first (cheap, fast feedback), tests second, deploy last."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I stop a stuck workflow run?"}, {"role": "assistant", "content": "Open the Actions tab, click the run, and use the 'Cancel workflow' button (or the three-dot menu). You can also cancel from the CLI: `gh run cancel <run-id>` or `gh run list` then `gh run cancel`. For recurring stuck schedules, check `concurrency:` — without it, overlapping runs can pile up. Set `cancel-in-progress: true` and a `timeout-minutes` on long-running jobs."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow that checks the repository for merge conflicts on PRs."}, {"role": "assistant", "content": "```yaml\nname: Merge Conflict Check\n\non:\n  pull_request:\n\njobs:\n  check:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n        with:\n          fetch-depth: 0\n      - name: Check for conflict markers\n        run: |\n          if git grep -nE '^(<<<<<<<|=======|>>>>>>>) ' -- . ':!*.lock' ':!package-lock.json'; then\n            echo \"::error::Merge conflict markers found\"\n            exit 1\n          fi\n          echo \"No conflict markers found\"\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is the fastest way to reduce Actions minutes?"}, {"role": "assistant", "content": "1) Path filters so docs-only changes skip CI. 2) Dependency caching — biggest single win for install-heavy repos. 3) `workflow_dispatch` for heavy jobs instead of running them on every push. 4) Matrix only where needed — each extra matrix cell costs a full job. 5) Run lint/format locally via pre-commit so CI only enforces. 6) For PRs from the same repo, `pull_request` runs twice (head + merge) if you also have `push` — decide which you actually need."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Build a workflow that lints, tests, and releases a Docker image to GHCR on tag pushes."}, {"role": "assistant", "content": "```yaml\nname: Build and Publish Docker Image\n\non:\n  push:\n    tags: ['v*']\n\npermissions:\n  contents: read\n  packages: write\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: docker/setup-buildx-action@v3\n      - uses: docker/login-action@v3\n        with:\n          registry: ghcr.io\n          username: ${{ github.actor }}\n          password: ${{ secrets.GITHUB_TOKEN }}\n      - uses: docker/build-push-action@v6\n        with:\n          context: .\n          push: true\n          tags: |\n            ghcr.io/${{ github.repository }}:latest\n            ghcr.io/${{ github.repository }}:${{ github.ref_name }}\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow that uploads pytest coverage reports as artifacts."}, {"role": "assistant", "content": "```yaml\nname: Test with Coverage\n\non:\n  push:\n  pull_request:\n\njobs:\n  test:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: pip install -e .[test]\n      - run: pytest -v --cov=src --cov-report=xml --cov-report=html\n      - uses: actions/upload-artifact@v4\n        with:\n          name: coverage-report\n          path: htmlcov/\n          retention-days: 14\n      - uses: codecov/codecov-action@v5\n        with:\n          files: coverage.xml\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Why does my workflow not see secrets?"}, {"role": "assistant", "content": "Likely causes: (1) the secret is defined at repo level but the workflow uses an environment secret — reference the job's `environment:`; (2) the run came from a fork — fork PRs do not receive secrets; (3) the secret name has invalid characters (only alphanumeric + underscore, and cannot start with a number or `GITHUB_`); (4) you referenced `${{ secrets.X }}` inside a `run:` block that is a shell expansion — use `env:` mapping instead: ```yaml\n- run: deploy --token \"$TOKEN\"\n  env:\n    TOKEN: ${{ secrets.X }}\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Create a workflow that validates YAML files in a repo (e.g. .github/workflows itself)."}, {"role": "assistant", "content": "```yaml\nname: Validate YAML\n\non:\n  push:\n    paths: ['**.yml', '**.yaml']\n  pull_request:\n    paths: ['**.yml', '**.yaml']\n\njobs:\n  validate:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: python -m pip install pyyaml\n      - name: Parse all YAML files\n        run: |\n          python - <<'EOF'\n          import pathlib, sys\n          import yaml\n          errors = []\n          for p in pathlib.Path('.').rglob('*.y*ml'):\n              if '.git' in p.parts:\n                  continue\n              try:\n                  yaml.safe_load(p.read_text())\n              except Exception as e:\n                  errors.append(f\"{p}: {e}\")\n          if errors:\n              print(\"\\n\".join(errors), file=sys.stderr)\n              sys.exit(1)\n          print(\"All YAML files valid\")\n          EOF\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is fail-fast and when should I turn it off?"}, {"role": "assistant", "content": "`fail-fast: true` (default) cancels all other matrix jobs as soon as one fails, saving minutes. Set `strategy: fail-fast: false` when you need the full matrix results (e.g., checking a feature across every OS/Python version, or collecting all failures for a report)."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do secrets work in GitHub Actions?"}, {"role": "assistant", "content": "Secrets are encrypted values stored at repository, environment, or organization level. They are never printed in logs (the runner masks them) and are referenced as `${{ secrets.NAME }}` or exported to env: ```yaml\nenv:\n  API_KEY: ${{ secrets.API_KEY }}\n```\nThey are not available to workflows triggered from forks unless you use `pull_request_target` (which carries security trade-offs). Environment secrets can be gated by protection rules, e.g. required reviewers or a wait timer."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What are the hosted runner images?"}, {"role": "assistant", "content": "GitHub-hosted runners: `ubuntu-latest` (22.04/24.04), `windows-latest` (Server 2022), `macos-latest` (14/15), plus `-4-core`, `-8-core`, `-16-core` variants for more CPU/RAM. Public repositories get 2,000 free minutes/month (Linux); Windows/macOS minutes cost 2x/10x. `ubuntu-latest` is the usual default. You can also pin `ubuntu-24.04` explicitly to avoid surprise image updates."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Why is my GITHUB_TOKEN giving '403 Resource not accessible by integration'?"}, {"role": "assistant", "content": "That error means the token lacks the permission for the API call. GITHUB_TOKEN defaults to read-only `contents` on new repos. If you call the issues, PR, or releases API, grant the scope explicitly: ```yaml\npermissions:\n  contents: write\n  pull-requests: write\n  issues: write\n```\nIf you use a `PAT`/`fine-grained` token, also check its own scopes. For `gh api` calls, use `gh api` with the same `permissions:` block. Remember: tokens can only grant what the repository settings allow."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow that runs on PRs and skips when the PR is a draft."}, {"role": "assistant", "content": "```yaml\nname: CI\n\non:\n  pull_request:\n\njobs:\n  test:\n    if: github.event.pull_request.draft == false\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: pip install -e .[test]\n      - run: pytest -v\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I debug a failing workflow?"}, {"role": "assistant", "content": "1) Re-run with debug logging enabled by setting the repo/run secret `ACTIONS_STEP_DEBUG=true` — every step prints `##[debug]` lines. 2) Use `ACTIONS_RUNNER_DEBUG=true` for runner-level logs. 3) Add a temporary step to inspect state: `run: env` prints all env vars; `run: pwd && ls -la` checks the workspace. 4) Check the failing step's log under the run page, and expand group sections (`::group::` / `::endgroup::`). 5) For interactive debugging, install `mxschmitt/action-tmate@v3` as a temporary step to SSH into the runner. Always remove debug steps before merge."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "My Docker build action needs the image tag to include the git SHA — how?"}, {"role": "assistant", "content": "Use `github.sha` (full 40-char SHA) or `github.sha` truncated via an expression like `${{ github.sha }}` for the full value: ```yaml\n- uses: docker/build-push-action@v6\n  with:\n    tags: ghcr.io/${{ github.repository }}:${{ github.sha }}\n```\nFor a short SHA, compute it in a step: `echo \"sha_short=${GITHUB_SHA::7}\" >> \"$GITHUB_OUTPUT\"` then use `${{ steps.x.outputs.sha_short }}`."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I pin action versions for security?"}, {"role": "assistant", "content": "Pin to a full-length commit SHA for supply-chain safety, with the tag as a comment: ```yaml\n- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2\n```\nFor community actions you trust less, prefer the SHA; for well-known actions, pinning the major tag (`@v4`) is common and gets patch updates. Enable Dependabot's GitHub Actions updates (`.github/dependabot.yml`) to keep versions fresh automatically."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "My workflow only runs on the default branch, but I pushed to a feature branch and nothing happened."}, {"role": "assistant", "content": "Check the `on:` block. If you wrote `on: push` with no `branches:` filter it runs on every push, including feature branches. If you wrote `branches: [main]`, pushes to feature branches are intentionally ignored — that is the filter doing its job. If you expected the workflow to run but it did not, check: (1) the file is in `.github/workflows/` with a `.yml`/`.yaml` extension; (2) the file is committed on the branch you pushed; (3) the workflow is not disabled in the Actions tab. Also note `schedule` events only fire on the default branch by default."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I schedule a workflow with cron?"}, {"role": "assistant", "content": "Use the `schedule` event with POSIX cron syntax, in UTC: ```yaml\non:\n  schedule:\n    - cron: '0 2 * * *'   # daily 02:00 UTC\n```\nNotes: the minimum interval is 5 minutes; schedules can be delayed by runner load; and a scheduled workflow only runs on the default branch. A scheduled run's default branch is checked out, so use `actions/checkout@v4` with the ref you actually want."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow with a matrix across operating systems and Python versions for tests."}, {"role": "assistant", "content": "```yaml\nname: Test Matrix\n\non:\n  push:\n  pull_request:\n\njobs:\n  test:\n    runs-on: ${{ matrix.os }}\n    strategy:\n      fail-fast: false\n      matrix:\n        os: [ubuntu-latest, windows-latest, macos-latest]\n        python-version: ['3.10', '3.11', '3.12']\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: ${{ matrix.python-version }}\n      - run: pip install -e .[test]\n      - run: pytest -v\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Explain this GitHub Actions workflow:\n```yaml\nname: Build\non:\n  push:\n    tags: ['v*']\npermissions:\n  contents: write\njobs:\n  release:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - name: Get version\n        id: version\n        run: echo \"tag=${GITHUB_REF_NAME#v}\" >> \"$GITHUB_OUTPUT\"\n      - uses: softprops/action-gh-release@v2\n        with:\n          tag_name: ${{ github.ref_name }}\n          name: Release ${{ steps.version.outputs.tag }}\n```"}, {"role": "assistant", "content": "A tag-triggered release workflow. It only fires when a tag matching `v*` is pushed (e.g. `v1.2.0`). `contents: write` is required because creating a GitHub Release is a contents write. The first step checks out the repo, the 'Get version' step extracts the tag without the leading `v` into a job-scoped step output via `$GITHUB_OUTPUT`, and `softprops/action-gh-release@v2` creates the release using the full tag and the cleaned version as the title."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What are environments in GitHub Actions?"}, {"role": "assistant", "content": "Environments group secrets and add protection rules for sensitive targets: ```yaml\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    environment: production\n    steps:\n      - run: echo \"Deploying\"\n```\nEnvironment protection rules can require reviewers to approve before a job runs, add a wait timer, or restrict which branches can deploy. Use separate environments (staging, production) so production secrets are only available to approved deploys."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a GitHub Actions workflow to run CodeQL security scanning on a Python repo."}, {"role": "assistant", "content": "```yaml\nname: CodeQL\n\non:\n  push:\n    branches: [main]\n  pull_request:\n  schedule:\n    - cron: '0 4 * * 1'\n\npermissions:\n  contents: read\n  security-events: write\n\njobs:\n  analyze:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: github/codeql-action/init@v3\n        with:\n          languages: python\n      - uses: github/codeql-action/analyze@v3\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is the difference between push and pull_request triggers?"}, {"role": "assistant", "content": "`push` fires when commits are pushed to a branch (including to the default branch); `pull_request` fires when a PR is opened, updated, reopened, or synchronized against the target branch. The PR run uses the MERGE of the PR branch with the base, not just the head. Common setup: run CI on both, but deploy only on `push` to `main` (or on tags)."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What are step exit codes and how do they affect a job?"}, {"role": "assistant", "content": "Each `run:` step is a shell command; non-zero exit code fails that step and the whole job, and dependent jobs are skipped unless they use `if: always()` or `if: failure()`. `continue-on-error: true` marks the step as a warning instead of failing the job (useful for linters with warnings). `timeout-minutes` per job and per step prevents hangs."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is a reusable workflow?"}, {"role": "assistant", "content": "A reusable workflow is a workflow that another workflow calls with `uses:`. The callee declares `on: workflow_call:` with typed inputs, secrets, and outputs: ```yaml\n# .github/workflows/build.yml\non:\n  workflow_call:\n    inputs:\n      python-version:\n        required: true\n        type: string\n    secrets:\n      PYPI_TOKEN:\n        required: true\n```\nCaller: ```yaml\njobs:\n  build:\n    uses: owner/repo/.github/workflows/build.yml@main\n    with:\n      python-version: '3.12'\n    secrets:\n      PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}\n```\nReusable workflows cannot be triggered by events themselves; they must be called. They also cannot use `run:` steps at the top level — only called jobs."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is GitHub Actions?"}, {"role": "assistant", "content": "GitHub Actions is GitHub's built-in CI/CD platform. Workflows are YAML files placed in `.github/workflows/` at the repository root. They are triggered by events (push, pull_request, schedule, workflow_dispatch, and many more) and run on GitHub-hosted runners (ubuntu-latest, windows-latest, macos-latest) or self-hosted runners. Each workflow contains jobs, and each job contains steps that run commands or use community actions."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I pass a multiline value into GITHUB_OUTPUT?"}, {"role": "assistant", "content": "Use the heredoc delimiter syntax: ```yaml\n- id: notes\n  run: |\n    echo 'notes<<EOF' >> \"$GITHUB_OUTPUT\"\n    printf '%s\\n' \"line one\" \"line two\" >> \"$GITHUB_OUTPUT\"\n    echo 'EOF' >> \"$GITHUB_OUTPUT\"\n```\nThen reference `${{ steps.notes.outputs.notes }}`. The delimiter must be unique and cannot contain special regex chars. Never put the delimiter in the content. This is the replacement for the deprecated `set-output` workflow command."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Create a workflow that deploys a static site to GitHub Pages when pushed to main."}, {"role": "assistant", "content": "```yaml\nname: Deploy to GitHub Pages\n\non:\n  push:\n    branches: [main]\n\npermissions:\n  contents: read\n  pages: write\n  id-token: write\n\nconcurrency:\n  group: pages\n  cancel-in-progress: true\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-node@v4\n        with:\n          node-version: 20\n          cache: npm\n      - run: npm ci\n      - run: npm run build\n      - uses: actions/upload-pages-artifact@v3\n        with:\n          path: dist\n\n  deploy:\n    needs: build\n    runs-on: ubuntu-latest\n    environment:\n      name: github-pages\n      url: ${{ steps.deployment.outputs.page_url }}\n    steps:\n      - id: deployment\n        uses: actions/deploy-pages@v4\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What are the top GitHub Actions security best practices?"}, {"role": "assistant", "content": "1) Pin action versions — ideally full commit SHAs for critical paths, at least major tags (`@v4`) for well-known actions. 2) Grant least-privilege `permissions:` — never default to write; use `contents: read` plus only what is needed. 3) Never use `pull_request_target` casually; it runs base-branch code with repo secrets and is the top attack vector. 4) Don't echo secrets into files or logs; map them via `env:`. 5) Avoid shell interpolation of untrusted input — pass via env and use JSON.parse for GitHub-Script. 6) Pin runner versions (`ubuntu-24.04`) for reproducibility. 7) Enable Dependabot for Actions and Docker. 8) Use OIDC instead of long-lived cloud keys. 9) Scan third-party actions before adopting them."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Explain this GitHub Actions workflow:\n```yaml\nname: Deploy\non:\n  workflow_dispatch:\n    inputs:\n      env:\n        type: choice\n        options: [staging, production]\npermissions:\n  id-token: write\n  contents: read\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    environment: ${{ inputs.env }}\n    steps:\n      - uses: actions/checkout@v4\n      - uses: aws-actions/configure-aws-credentials@v4\n        with:\n          role-to-assume: arn:aws:iam::123456789012:role/deploy-${{ inputs.env }}\n          aws-region: us-east-1\n      - run: ./deploy.sh\n```"}, {"role": "assistant", "content": "This is a manual deploy workflow with OIDC. `workflow_dispatch` means it only runs when a human clicks 'Run workflow' in the Actions tab, choosing `staging` or `production`. The `permissions` block grants `id-token: write` for OIDC and read-only contents. The job targets the chosen environment, so environment-scoped secrets and protection rules apply. It uses `aws-actions/configure-aws-credentials@v4` to assume a role named per environment — no long-lived AWS keys stored as secrets. Finally it runs `deploy.sh`. Note `permissions` is scoped at workflow level, so the deploy job does not have extra repo write rights."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is the difference between env, vars, and secrets?"}, {"role": "assistant", "content": "`secrets` are encrypted, masked, and set in the UI or API. `vars` are plain-text repository/org/environment variables (no masking) — good for non-sensitive config like image names or timeouts. `env` is the workflow-scoped runtime environment you define in YAML, typically referencing secrets/vars: ```yaml\nenv:\n  IMAGE: ${{ vars.IMAGE_NAME }}\n  TOKEN: ${{ secrets.TOKEN }}\n```\nPrecedence (lowest to highest): repository vars, environment vars, workflow `env`, job `env`, step `env`."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I approve a workflow from a first-time contributor?"}, {"role": "assistant", "content": "First-time contributor PRs require manual approval before workflows run. To still run CI on those PRs, GitHub shows 'First-time contributor' on the run and a maintainer clicks 'Approve and run'. You cannot auto-approve safely; using `pull_request_target` to bypass this is a common supply-chain attack vector. If you must run untrusted code, do it in a sandboxed job without secrets."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Build a reusable workflow for Python tests and show how another workflow calls it."}, {"role": "assistant", "content": "```yaml\n# .github/workflows/python-tests.yml (reusable)\nname: Python Tests\n\non:\n  workflow_call:\n    inputs:\n      python-version:\n        type: string\n        required: true\n    secrets:\n      CODECOV_TOKEN:\n        required: false\n\njobs:\n  test:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: ${{ inputs.python-version }}\n          cache: pip\n      - run: pip install -e .[test]\n      - run: pytest -v --cov=src\n      - name: Upload coverage\n        if: ${{ secrets.CODECOV_TOKEN != '' }}\n        uses: codecov/codecov-action@v5\n        with:\n          token: ${{ secrets.CODECOV_TOKEN }}\n```\n\nCaller:\n```yaml\n# .github/workflows/ci.yml\nname: CI\n\non:\n  push:\n    branches: [main]\n  pull_request:\n\njobs:\n  tests:\n    uses: ./.github/workflows/python-tests.yml\n    with:\n      python-version: '3.12'\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a release workflow that creates a GitHub Release with changelog notes when a tag is pushed."}, {"role": "assistant", "content": "```yaml\nname: Release\n\non:\n  push:\n    tags: ['v*']\n\npermissions:\n  contents: write\n\njobs:\n  release:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - name: Build changelog\n        id: changelog\n        run: |\n          echo \"notes<<EOF\" >> \"$GITHUB_OUTPUT\"\n          git log --oneline --no-merges \"${{ github.event.before }}\"..\"${{ github.ref_name }}\" >> \"$GITHUB_OUTPUT\"\n          echo \"EOF\" >> \"$GITHUB_OUTPUT\"\n      - name: Create Release\n        uses: softprops/action-gh-release@v2\n        with:\n          body: ${{ steps.changelog.outputs.notes }}\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow that runs Terraform plan on pull requests and apply on merge to main."}, {"role": "assistant", "content": "```yaml\nname: Terraform\n\non:\n  pull_request:\n    paths: ['infra/**']\n  push:\n    branches: [main]\n    paths: ['infra/**']\n\npermissions:\n  contents: read\n  pull-requests: write\n  id-token: write\n\njobs:\n  terraform:\n    runs-on: ubuntu-latest\n    defaults:\n      run:\n        working-directory: infra\n    steps:\n      - uses: actions/checkout@v4\n      - uses: hashicorp/setup-terraform@v3\n        with:\n          terraform_version: 1.8.0\n      - uses: aws-actions/configure-aws-credentials@v4\n        with:\n          role-to-assume: arn:aws:iam::123456789012:role/ci-role\n          aws-region: us-east-1\n      - run: terraform init\n      - name: Plan\n        id: plan\n        run: terraform plan -no-color\n        continue-on-error: true\n      - name: Comment plan on PR\n        if: github.event_name == 'pull_request'\n        uses: actions/github-script@v7\n        with:\n          script: |\n            github.rest.issues.createComment({\n              issue_number: context.issue.number,\n              owner: context.repo.owner,\n              repo: context.repo.repo,\n              body: '```terraform\\n' + process.env.PLAN + '\\n```'\n            })\n        env:\n          PLAN: ${{ steps.plan.outputs.stdout }}\n      - name: Apply\n        if: github.event_name == 'push' && github.ref == 'refs/heads/main'\n        run: terraform apply -auto-approve\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is OIDC in GitHub Actions?"}, {"role": "assistant", "content": "OpenID Connect (OIDC) lets a workflow request short-lived credentials from cloud providers (AWS, Azure, GCP) without storing long-lived keys. Enable it with `permissions: id-token: write` and configure the cloud side to trust your repository. Example for AWS: ```yaml\npermissions:\n  id-token: write\n  contents: read\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: aws-actions/configure-aws-credentials@v4\n        with:\n          role-to-assume: arn:aws:iam::123456789012:role/deploy-role\n          aws-region: us-east-1\n```\nOIDC removes the need to rotate cloud credentials and is the recommended pattern for deploys."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "When should I use a reusable workflow instead of copying YAML?"}, {"role": "assistant", "content": "Use a reusable workflow when three or more workflows share the same job logic — common test, build, or deploy steps. Benefits: single source of truth, versioned via the `@ref` in `uses:`, and consistent behavior across repos. Costs: indirection (a bug is harder to find), and you cannot use `run:` at the caller level of the reused workflow. For a single repo, `.github/workflows/reusable.yml` + `.` prefix (`uses: ./.github/workflows/reusable.yml`) is the simplest. For an org, publish to a central repo and reference by owner/repo@ref."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "My GitHub Actions step failed with: Process completed with exit code 1, but I don't know why."}, {"role": "assistant", "content": "Exit code 1 means a command failed. Steps to diagnose: (1) open the step log and scroll to the end — the actual error (traceback, linter message, test failure) is usually there; (2) set the repository secret `ACTIONS_STEP_DEBUG=true` and re-run to see `##[debug]` output; (3) temporarily add `run: env` and `run: pwd && ls -la` to inspect state; (4) if the command is pip-installing from a private repo, check credentials; (5) if a test command fails, read the pytest/npm summary. The message `##[error]Process completed with exit code 1` is generic — the details are above it."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow that publishes a Python package to PyPI when a version tag is pushed."}, {"role": "assistant", "content": "```yaml\nname: Publish to PyPI\n\non:\n  push:\n    tags: ['v*']\n\npermissions:\n  contents: read\n\njobs:\n  publish:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: '3.12'\n      - run: python -m pip install --upgrade build\n      - run: python -m build\n      - uses: pypa/gh-action-pypi-publish@release/v1\n        with:\n          password: ${{ secrets.PYPI_TOKEN }}\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I fail a workflow if a condition is not met?"}, {"role": "assistant", "content": "Use an `if:` guard on a step plus a sentinel: ```yaml\n- name: Require changelog\n  if: ${{ !contains(github.event.pull_request.files.*.filename, 'CHANGELOG.md') }}\n  run: exit 1\n```\nOr better, use a dedicated check action. To fail only on a specific condition without masking real errors, keep the `if:` narrow and the command explicit."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I make secrets available only for production deploys?"}, {"role": "assistant", "content": "Store production secrets at the environment level, not repo level. Create an environment named `production` (Settings → Environments), add the secrets there, and set a protection rule (e.g. required reviewers). Then target it from the job: ```yaml\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    environment: production\n```\nThe secrets `${{ secrets.PROD_KEY }}` are only injected when that job runs with the `production` environment, and the protection rule gates who can trigger it."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "My scheduled workflow ran but the code is outdated — why?"}, {"role": "assistant", "content": "Scheduled workflows check out the default branch at run time, but the checkout step is just `actions/checkout@v4` without a ref. If a later commit changed the workflow file, the run uses the workflow from the default branch as of the run. To be explicit, pass a ref: ```yaml\n- uses: actions/checkout@v4\n  with:\n    ref: main\n```\nAlso confirm the schedule cron is UTC and that you pushed the workflow file to the default branch (schedules only trigger from it)."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is the workflow_dispatch event?"}, {"role": "assistant", "content": "`workflow_dispatch` lets you start a workflow manually from the Actions tab. It supports typed inputs: ```yaml\non:\n  workflow_dispatch:\n    inputs:\n      environment:\n        description: 'Target environment'\n        required: true\n        default: staging\n        type: choice\n        options: [staging, production]\n```\nRead inputs in a step with `${{ github.event.inputs.environment }}` or, more robustly, `inputs.environment` in the job/step context."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What does CI/CD stand for and what's the difference?"}, {"role": "assistant", "content": "CI (Continuous Integration) means automatically building and testing every push or pull request so integration problems are caught early. CD (Continuous Delivery/Deployment) means automatically preparing or shipping the verified artifact to a target: staging, production, a package registry, or a container registry. CI answers 'does this change work?'; CD answers 'is it safely delivered?' GitHub Actions handles both in the same YAML workflow files."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What are the core components of a GitHub Actions workflow?"}, {"role": "assistant", "content": "A workflow file has four main parts: (1) `name` — a human-readable label; (2) `on` — the events that trigger it, optionally filtered by branches, paths, or tags; (3) `jobs` — units of work that run on runners, by default in parallel unless linked with `needs`; (4) inside each job, `steps` — the sequential commands and `uses:` action references. You can also set `permissions`, `env`, `concurrency`, `defaults`, and a job-level `strategy` for matrix builds."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a workflow that triggers only when the pyproject.toml or package files change."}, {"role": "assistant", "content": "```yaml\nname: Package Check\n\non:\n  push:\n    paths:\n      - 'pyproject.toml'\n      - 'setup.py'\n      - 'setup.cfg'\n      - 'requirements*.txt'\n  pull_request:\n    paths:\n      - 'pyproject.toml'\n      - 'setup.py'\n      - 'setup.cfg'\n      - 'requirements*.txt'\n\njobs:\n  check:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - run: python -m pip install -e . --dry-run\n      - run: python -m pip check\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is a composite action?"}, {"role": "assistant", "content": "A composite action bundles multiple steps into one reusable action, defined with `runs.using: composite`. It lives in `action.yml` at the repository root: ```yaml\nname: 'Lint Python'\ndescription: 'Run ruff over a Python repo'\ninputs:\n  path:\n    description: 'Directory to lint'\n    default: '.'\nruns:\n  using: 'composite'\n  steps:\n    - uses: actions/setup-python@v5\n      with:\n        python-version: '3.12'\n    - shell: bash\n      run: ruff check ${{ inputs.path }}\n```\nComposite actions can use `uses:` and `run:` steps but cannot use `if:` conditionals at the step level in older runners and cannot define environments or concurrency."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How does the cache action work?"}, {"role": "assistant", "content": "`actions/cache` caches a path keyed by a key string; on a hit it restores the files instantly: ```yaml\n- uses: actions/cache@v4\n  with:\n    path: ~/.cache/pip\n    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}\n    restore-keys: |\n      ${{ runner.os }}-pip-\n```\nBetter: language setup actions have built-in caching (`actions/setup-python@v5` with `cache: pip`). Cache is per branch and per event; PR caches are shared with the base branch. Cache size is limited (10 GB per repo), and caches are evicted after 7 days of no access."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I pass data between jobs?"}, {"role": "assistant", "content": "Two mechanisms: (1) artifacts for files, and (2) job outputs for values. Output example: ```yaml\njobs:\n  build:\n    runs-on: ubuntu-latest\n    outputs:\n      version: ${{ steps.version.outputs.value }}\n    steps:\n      - id: version\n        run: echo \"value=$(cat VERSION)\" >> \"$GITHUB_OUTPUT\"\n  deploy:\n    needs: build\n    runs-on: ubuntu-latest\n    steps:\n      - run: echo \"${{ needs.build.outputs.version }}\"\n```\nNote the `$GITHUB_OUTPUT` file syntax — `echo \"k=v\" >> \"$GITHUB_OUTPUT\"` (the old `set-output` command is deprecated)."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I set up Python in a workflow?"}, {"role": "assistant", "content": "```yaml\n- uses: actions/setup-python@v5\n  with:\n    python-version: '3.12'\n    cache: pip\n    cache-dependency-path: '**/requirements*.txt'\n```\n`cache: pip` automatically restores `~/.cache/pip` keyed on the dependency files. Use `python-version: '3.x'` to get the latest 3.x. To test multiple versions, put it in a matrix."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "How do I use the gh CLI inside a workflow?"}, {"role": "assistant", "content": "The runner comes with `gh` pre-installed and pre-authenticated with GITHUB_TOKEN: ```yaml\n- run: |\n    gh pr comment \"${{ github.event.pull_request.number }}\" --body \"Lint passed\"\n```\nFor API calls not covered by gh, use `gh api`. The token's scope is controlled by `permissions:` — to comment on a PR you need `pull-requests: write`."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "Write a CI workflow for a Python project that lints with ruff and runs pytest on every push and pull request."}, {"role": "assistant", "content": "```yaml\nname: Python CI\n\non:\n  push:\n    branches: [main]\n  pull_request:\n\njobs:\n  test:\n    runs-on: ubuntu-latest\n    strategy:\n      matrix:\n        python-version: ['3.11', '3.12']\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with:\n          python-version: ${{ matrix.python-version }}\n          cache: pip\n      - run: python -m pip install --upgrade pip\n      - run: pip install ruff pytest\n      - run: ruff check .\n      - run: pytest -v\n```"}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What is the difference between a job and a step?"}, {"role": "assistant", "content": "A job is a unit of work that runs on its own runner (a fresh VM or container). Jobs in a workflow run in parallel by default, and you chain them with `needs:`. A step is one command or one action inside a job; steps always run sequentially on that job's runner and share its filesystem and environment. Data between jobs is exchanged via artifacts or job outputs, not shared directly."}]}
{"messages": [{"role": "system", "content": "You are SakThai-CI, Beer's GitHub Actions and CI/CD specialist. You write correct, production-ready GitHub Actions workflows and explain CI/CD concepts clearly. When asked for a workflow, return the complete YAML in a code block. Be precise about event triggers, permissions, and syntax."}, {"role": "user", "content": "What are artifacts and how do I use them?"}, {"role": "assistant", "content": "Artifacts persist files after a job finishes and let later jobs download them: ```yaml\n- uses: actions/upload-artifact@v4\n  with:\n    name: dist\n    path: dist/\n```\nIn a later job: ```yaml\n- uses: actions/download-artifact@v4\n  with:\n    name: dist\n    path: dist/\n```\nArtifacts live up to 90 days (configurable via `retention-days`), are available on the Actions run page, and are the standard way to pass build outputs between jobs."}]}