@caddis/cli 0.0.0 → 0.2.0

package/bundles/antigravity-plugin/skills/setup-project-ai/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: setup-project-ai
+description: Install or refresh the agent-agnostic dev harness in this project (AGENTS.md-canonical rules hierarchy + CLAUDE.md @import shims, subagents, commands, settings)
+---
+
+# /setup-project-ai — install the harness
+
+Set up (or refresh) the agent-agnostic development harness for this project. Follow the
+`setup-project-ai` skill end-to-end: run the deterministic generator, resolve any reported
+placeholders, enrich the generated AGENTS.md rules hierarchy (the canonical files — never the CLAUDE.md
+shims) with project-specific facts, ensure the test env, and smoke-test.
+
+Context / args: **$ARGUMENTS**
+
+Load and follow the `setup-project-ai` skill. Do not hand-roll the steps — the deterministic parts
+must go through the bundled generator so they don't vary. Resolve its path per the skill's Step 1:
+- Plugin install: `${CLAUDE_PLUGIN_ROOT}/scripts/setup_project_ai.py`
+- harness (caddis) checkout: `scripts/setup_project_ai.py`
+
+## After the deterministic step — install the claude-oss / claude-glm launchers (optional)
+
+`claude-oss` / `claude-glm` (see `/caddis:use-model`) let a session run on an OSS provider (GLM,
+DeepSeek, OpenRouter). They live at `claude-harness/scripts/claude-oss.{sh,ps1}`. This step never
+silently edits the user's shell profile — print the one-liner and let them run it:
+
+```powershell
+# PowerShell — add to $PROFILE (or run once per session):
+function claude-oss { & "<path-to>\claude-harness\scripts\claude-oss.ps1" @args }
+function claude-glm  { & "<path-to>\claude-harness\scripts\claude-oss.ps1" @args }
+```
+```bash
+# bash/zsh — add to ~/.bashrc / ~/.zshrc:
+alias claude-oss="<path-to>/claude-harness/scripts/claude-oss.sh"
+alias claude-glm="<path-to>/claude-harness/scripts/claude-oss.sh"
+```
+Resolve `<path-to>` per the same plugin-vs-source rule as the generator itself (`${CLAUDE_PLUGIN_ROOT}`
+for a plugin install, the harness checkout path for caddis). Also set `CADDIS_KEYS_FILE`
+(default `~/.claudster/keys.env`) with the provider keys — see `docs/guide/providers-and-keys.md`.
+
+## After the deterministic step — deploy private harness skills (optional)
+
+Some harness authors keep **private** skills on disk (organization-specific deploy/workflow skills, for
+example) that are **not** shipped in the public plugin. This step is for a local harness author who keeps
+such a source on disk; it is a no-op for everyone else. Point `CADDIS_HARNESS_SRC` at your harness root
+(the folder containing your private `skills/private/`) and run:
+
+```powershell
+# CADDIS_HARNESS_SRC is current; CLAUDSTER_HARNESS_SRC is read as a one-version fallback.
+$harnessSrc = if ($env:CADDIS_HARNESS_SRC) { $env:CADDIS_HARNESS_SRC } else { $env:CLAUDSTER_HARNESS_SRC }
+$src = if ($harnessSrc) { Join-Path $harnessSrc "skills\private" } else { $null }
+$dest = ".github\skills\private"
+if ($src -and (Test-Path $src)) {
+    New-Item -ItemType Directory -Force $dest | Out-Null
+    Copy-Item "$src\*" $dest -Recurse -Force
+    Write-Host "private skills deployed to $dest"
+} else {
+    Write-Host "private harness source not found (set CADDIS_HARNESS_SRC) — skipping; public installs have none."
+}
+```
+
+Do not commit these private skills to the project repo — they are private harness resources.

package/bundles/antigravity-plugin/skills/ship/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: ship
+description: Commit, push, and monitor the deploy pipeline (auto-detects Gitea, GitHub Actions, or local-only)
+---
+
+# /ship — commit → push → CI → prod
+
+Ship the current working changes via this repo's actual delivery pipeline. The pipeline differs per
+repo, so **detect it first**, then follow the matching lane. Preflight, staging, and commit are
+identical across lanes; only monitoring and validation differ.
+
+> **This is the express lane** — on repos where a push to the default branch deploys, `/ship` sends
+> work straight to prod with no review pause. Right for a hotfix. **For feature work, use the
+> reviewed lane instead: `/ship-pr`** (open a PR, monitor CI, stop at green) **→ `/ship-merge`**
+> (merge the green PR behind a deploy-confirm, validate, clean up).
+
+Optional message: **$ARGUMENTS** (if empty, derive a conventional commit message from staged changes)
+
+## Step 0 — Detect the pipeline (do this before anything else)
+Inspect the repo and pick exactly one lane:
+- **Gitea lane** — `.gitea/workflows/` exists. Monitor via the Gitea API; follow the `deploy-local`
+  skill (CalVer/NSSM prod deploy). This is the harness's local deploy setup.
+- **GitHub lane** — `.github/workflows/` exists (and no `.gitea/`). Monitor via the `gh` CLI.
+- **Local-only lane** — neither exists, or there is no push remote. Commit (and push if a remote
+  exists); there is no CI to monitor — say so explicitly and stop after the push + local validation.
+
+Read `AGENTS.md` and the detected workflow file(s) before starting so you use this repo's real gate
+names, branch, and service identifiers — never assume.
+
+## Steps 1–3 — common to every lane
+
+**1. PREFLIGHT** — Run local quality gates that mirror CI:
+- Backend: `ruff check .` (must be clean before any commit)
+- Frontend: `npm run typecheck && npm run build` (if `frontend/` exists)
+- Tests: run only if the user says they're needed or a gate explicitly requires them
+- Fix any failures before proceeding. Do not commit broken code.
+
+**2. STAGE + COMMIT** — Stage only the intended files (never `git add -A` blindly):
+```
+git status --short      # confirm what's staged
+git add <specific files>
+git commit -m "<type>(<scope>): <message>"
+git rev-parse HEAD      # record SHA for monitoring
+```
+Use conventional commits: `fix:`, `feat:`, `chore:`, `refactor:`, `docs:`. Scope = affected module.
+
+**3. PUSH** — to the repo's default branch (confirm the branch first; don't assume `main`):
+```
+git push origin <branch>
+```
+Confirm the push succeeded and the SHA is accepted by the remote. (Local-only lane: skip if there is
+no remote, and note that nothing was pushed.)
+
+## Step 4 — MONITOR CI (lane-specific)
+
+**Gitea lane** — Poll the Gitea API using the token from `config/.env.gitea` (load it first):
+```powershell
+$envFile = Join-Path (Get-Location) "config/.env.gitea"
+# ... (load the bot token from file — see deploy-local skill)
+```
+Track jobs in order: `lint_and_test` → `frontend_checks` (if present) → `deploy_prod` →
+`release_metadata` → `notify`. Report status as each job completes. On failure, classify it and apply
+the minimum fix (see `deploy-local` skill §6).
+
+**GitHub lane** — Watch the run the push triggered via the `gh` CLI:
+```
+gh run list --branch <branch> --limit 1                 # find the run id for the pushed SHA
+gh run watch <run-id> --exit-status                      # stream until done; non-zero on failure
+gh run view <run-id> --log-failed                        # on failure, pull only the failing job logs
+```
+Report each job's status as it resolves. On failure, classify it and apply the minimum source fix.
+
+**Local-only lane** — no CI; skip monitoring.
+
+## Step 5 — PROD / POST-DEPLOY VALIDATION
+- **Gitea lane:** after `deploy_prod` succeeds — prod checkout SHA matches the pushed commit; NSSM
+  services for this repo are Running; health endpoint green; version endpoint shows the expected
+  SHA/CalVer (if exposed).
+- **GitHub lane:** if the workflow deploys, validate against its target the same way (deployed SHA /
+  health / version endpoint). If it's CI-only (no deploy job), confirm the run is green and stop.
+- **Local-only lane:** run the app's smoke/health check locally if one exists; otherwise report that
+  validation is limited to the green preflight.
+
+## Step 6 — REPORT
+```
+Repo:            <name>
+Pipeline:        gitea | github | local-only
+Commit:          <sha> — <message>
+CI jobs:         <job ✓ / ✗ per job, or "n/a (local-only)">
+Prod/Target SHA: matches ✓ | n/a
+Health:          green ✓ | n/a
+Release tag:     <tag> → <sha> | n/a
+```
+
+## Rules
+- Never push before preflight gates are green.
+- Never use `git add -A` without reviewing `git status` first.
+- Do not edit a workflow file (`.gitea/workflows/` or `.github/workflows/`) to make a failing gate
+  pass — fix the source.
+- Gitea lane: tag-triggered runs after `release_metadata` are expected; verify `deploy_prod` is
+  **skipped** in them.
+- If health is red after deploy, report it immediately — do not attempt a silent re-deploy.
+
+## Skill reference
+Full procedures for the Gitea lane (CI monitoring, prod validation, queue triage, failure remediation)
+are in `skills/devops/deploy-local/SKILL.md`. For the GitHub lane, the `gh-cli` skill covers `gh run`
+usage. Load whichever matches the detected lane when a step needs more detail.

package/bundles/antigravity-plugin/skills/ship-merge/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: ship-merge
+description: Merge an already-green, already-reviewed PR behind an explicit deploy-confirm, monitor the deploy, validate prod, then clean up the branch — only on green.
+---
+
+# /ship-merge — the reviewed lane, half 2: green PR → deployed → cleaned up
+
+The deliberate second door. `/ship-pr` produced a reviewable artifact and stopped; this command
+takes an **already-green, already-reviewed** PR through the one irreversible step — on these repos
+**merge == deploy** — then watches the deploy, validates prod, and cleans up the branch **only
+after** the deploy is confirmed green.
+
+This command **never creates a PR** — that is `/ship-pr`'s job. A single create-and-merge shot
+would recreate exactly what PRs exist to prevent: the ceremony of review with none of the pause.
+
+Argument: **$ARGUMENTS** (PR number/URL; if empty, infer the current branch's open PR). An optional
+strategy word (`squash` | `merge` | `rebase`) overrides the detected merge strategy.
+
+## Step 0 — Detect the lane, resolve the PR
+
+- **Gitea lane** — `.gitea/workflows/` exists: PR state + merge via the Gitea API; deploy
+  monitoring via the `deploy-local` skill.
+- **GitHub lane** — `.github/workflows/` (no `.gitea/`): `gh pr view/merge`, `gh run watch`
+  (the `gh-cli` skill).
+- **Local-only lane** — no forge, no PR concept: **refuse** and point at `/ship`. Stop.
+
+Resolve the target PR from `$ARGUMENTS`, else the current branch's open PR. No open PR → report
+that and point at `/ship-pr`. Read `AGENTS.md` + the workflow file(s) for the repo's real deploy
+job names and default branch — never assume.
+
+## Step 1 — Refuse unless green + mergeable + reviewed
+
+All of, per the repo's own rules:
+- **Required checks green** (including the scope-guard check when the repo has one).
+- **Mergeable** — no merge **conflicts** against the default branch.
+- **Reviewed** — if the repo configures **required** reviewers/approvals, they must be satisfied.
+  On a solo repo with none configured, Step 2's explicit human confirm IS the review gate.
+
+If anything fails: report **exactly what is missing** (which check is red, which review is absent,
+whether it conflicts) and **stop**. Never merge around a red or a rule.
+
+## Step 2 — Explicit human-confirm gate (the deploy warning)
+
+State plainly, then wait for confirmation:
+
+> Merging PR #N will **DEPLOY** `<head-sha>` to prod via the pipeline. Confirm to proceed.
+
+This is the one irreversible, outward-facing step. Approval here **does not carry over** to any
+future run — ask every time, even for the same PR five minutes later.
+
+## Step 3 — Merge
+
+Use the repo's configured **merge strategy** — read it from repo settings (Gitea repo settings API /
+`gh repo view --json squashMergeAllowed,mergeCommitAllowed,rebaseMergeAllowed`) and `AGENTS.md`;
+an explicit argument wins. Options: **squash**, **merge-commit**, rebase-merge. **Don't assume** —
+if detection is inconclusive, say so and use merge-commit (never silently squash someone's history).
+Record the merge SHA.
+
+## Step 4 — Monitor the deploy
+
+The merge lands on the default branch and triggers the pipeline. Watch it via the lane's skill:
+- Gitea: `lint_and_test` → `frontend_checks` (if present) → **`deploy_prod`** → `release_metadata`
+  → `notify` (`deploy-local` skill §monitoring; classify + minimum-fix on failure).
+- GitHub: `gh run watch <run-id> --exit-status` on the default branch; if the workflow has a deploy
+  job, watch it through; if CI-only, note that no deploy occurs.
+
+## Step 5 — Post-deploy validation
+
+- Prod/target checkout **SHA matches the merge commit**.
+- Services (NSSM or equivalent) **Running**; **health** endpoint green.
+- Version endpoint shows the expected SHA/CalVer, when exposed.
+(Same checklist as `/ship` Step 5 — reuse it.) If validation is red, report immediately; do not
+attempt a silent re-deploy — and **skip cleanup** (Step 6).
+
+## Step 6 — Branch cleanup — only after a confirmed-green deploy
+
+**Only after** Step 5 is green:
+- Delete the **remote** feature branch; delete the **local** feature branch.
+- Switch to the default branch and fast-forward it to the merge commit.
+- Drop the `backup/<branch>-preship` ref `/ship-pr` created.
+
+If deploy validation failed: **skip cleanup** entirely and say so — never delete a branch whose
+work may need re-work.
+
+## Step 7 — Report
+
+```
+PR:            #<n> <title> — merged (<strategy>) as <merge-sha>
+Deploy:        <job ✓ / ✗ per job>
+Prod SHA:      matches merge ✓ | MISMATCH
+Health:        green ✓ | red — reported, cleanup skipped
+Cleanup:       remote branch ✗ deleted / local ✗ deleted / backup ref dropped | SKIPPED (<why>)
+```
+
+## Rules
+- Never merge without: green required checks **and** the explicit human deploy-confirm.
+- Never delete a branch before its deploy is validated green.
+- Never `git add -A` without reviewing `git status`; never edit a workflow file to make a gate pass.
+- Local-only lane: no PR, no merge — refuse and point at `/ship`.
+
+## Skill reference
+Gitea deploy monitoring, prod validation, failure triage: `skills/devops/deploy-local/SKILL.md`.
+GitHub `gh pr merge` / `gh run` usage: the `gh-cli` skill.

package/bundles/antigravity-plugin/skills/ship-pr/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: ship-pr
+description: Open a reviewed PR for the current feature branch — rebase-safe push, PR create/update, monitor CI, STOP at green. Never merges, never deploys (that's /ship-merge).
+---
+
+# /ship-pr — the reviewed lane, half 1: branch → green PR
+
+Land feature-branch work as a **Pull Request** so CI + a human gate run **before** the deploy, not
+after. This command does the mechanics only: push safely, open (or update) the PR, watch its checks,
+and **stop at green** with a mergeability verdict. It **never merges and never deploys** — on these
+repos merge == deploy, so the merge stays a separate, deliberate act: `/ship-merge`.
+
+For a hotfix straight to the default branch, use `/ship` (the express lane) instead.
+
+Optional argument: **$ARGUMENTS** (PR title override; default = derived from the branch's
+conventional-commit summary).
+
+## Step 0 — Detect the lane (before anything else)
+
+- **Gitea lane** — `.gitea/workflows/` exists. PR + CI monitoring via the Gitea API (token loading
+  and job-polling procedure: the `deploy-local` skill).
+- **GitHub lane** — `.github/workflows/` exists (and no `.gitea/`). PR + monitoring via the `gh` CLI
+  (`gh pr create`, `gh pr checks` — see the `gh-cli` skill).
+- **Local-only lane** — neither exists, or there is no push remote. There is no PR concept here:
+  **refuse early**, tell the user to use `/ship`, and stop. Do not fabricate a PR flow.
+
+Read `AGENTS.md` + the detected workflow file(s) first for the repo's real gate names, default
+branch, and merge conventions — never assume `main`, never assume job names.
+
+## Step 1 — Refuse on the default branch
+
+A PR is *branch → default*. If HEAD **is** the default branch, stop and point at `/ship` — there is
+nothing to open a PR from. (Offer to create a feature branch from the current work if the changes
+are uncommitted.)
+
+## Step 2 — Preflight (local gates mirroring CI)
+
+- Backend: `ruff check .` clean.
+- Frontend: `npm run typecheck && npm run build` if `frontend/` exists.
+- Fix failures first. **Never open a PR over red preflight** — a PR that arrives red wastes the
+  reviewer it exists to serve.
+
+## Step 3 — Scope-guard pre-check (before the PR exists)
+
+- If the repo has a **named scope-guard workflow** (e.g. a Gitea `pr-scope-guard` that blocks PRs
+  mixing infra `.gitea/`/`.github/` changes with product `src/`/`frontend/`/`tests/` changes): read
+  the workflow's own rule and check the branch diff against exactly that rule **before** creating
+  the PR. On a violation, **refuse with the specific offending files** — do not let the guard fail
+  the PR after the fact.
+- Without a named guard, apply the generic infra-vs-product mixed-diff heuristic as a **warning
+  only** — surface it and proceed (repos without a guard allow mixed PRs by construction).
+
+## Step 4 — Rebase-safe currency
+
+- If the branch is **behind** the default branch, offer to rebase onto it (stale branches are how
+  merges rot). Only when behind — never rebase gratuitously.
+- If the branch was already pushed, a rebase rewrites history. **Snapshot first, then push safely:**
+  ```
+  git branch backup/<branch>-preship          # recovery ref BEFORE any rewrite
+  git rebase <default-branch>
+  git push --force-with-lease origin <branch> # never bare --force
+  ```
+
+## Step 5 — Push + create/update the PR
+
+- Push the branch (plain push if no rewrite happened).
+- Create the PR: title from the branch's conventional-commit summary (or `$ARGUMENTS`); body = the
+  commit list + a "generated by /ship-pr" note.
+- **Idempotent:** if a PR for this branch **already exists**, update its title/body and report it —
+  never error, never open a duplicate.
+
+## Step 6 — Monitor PR CI
+
+Watch the PR's checks job-by-job (never the deploy — PRs don't deploy here), including the
+scope-guard check when present:
+- Gitea lane: poll the run for the PR's head SHA via the API (`deploy-local` skill procedure).
+- GitHub lane: `gh pr checks <pr> --watch` / `gh run watch` (`gh-cli` skill).
+On a red check, classify the failure and apply the minimum **source** fix, then re-push (through
+Step 4's safety if history must change).
+
+## Step 7 — STOP at green, report
+
+```
+PR:          <url>
+Branch:      <branch> → <default-branch>  (rebased: yes/no, backup ref: backup/<branch>-preship | n/a)
+Checks:      <check ✓ / ✗ per check>
+Scope-guard: pass | warn (<files>) | n/a
+Mergeable:   YES — run /ship-merge <pr> when reviewed   |   BLOCKED by <exact reason>
+```
+This command's job ends here. **Never merge.** The merge is `/ship-merge`'s deliberately separate,
+human-confirmed door.
+
+## Rules
+- **Never merges, never deploys** — no merge action exists in this command, by design.
+- Never `git add -A` without reviewing `git status` first.
+- Never force-push without a `backup/*-preship` recovery ref; force pushes are `--force-with-lease` only.
+- Never edit a workflow file (`.gitea/workflows/`, `.github/workflows/`) to make a gate pass — fix the source.
+- Local-only lane: refuse + point at `/ship`. On the default branch: stop + point at `/ship`.
+
+## Skill reference
+Gitea API monitoring + failure triage: `skills/devops/deploy-local/SKILL.md`. GitHub `gh pr` / `gh run`
+usage: the `gh-cli` skill. Load whichever matches the detected lane.

package/bundles/antigravity-plugin/skills/skill-creator/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.