treebox 0.4.0__tar.gz → 0.6.0__tar.gz

{treebox-0.4.0 → treebox-0.6.0/.agents}/skills/treebox/SKILL.md

@@ -18,41 +18,42 @@ Provisioning (fetch → resolve branch → worktree add → copy submodules →
 ## Workflow
 
 1. Run `treebox doctor` (add `--isolation docker` to check the Docker daemon when docker isolation will be used).
-2. If creating and no branch is supplied, ask for a short valid Git branch name. Slashes are allowed, e.g. `feature/auth`.
-3. Create with `treebox create <branch> --base <trunk>`.
+2. If creating named work, ask for a short valid worktree name: one lowercase slug (`[a-z0-9-]+`). Omit it only when the user wants treebox to generate a petname.
+3. Create with `treebox create <name> --base <trunk>`, or use `treebox create [name] --checkout <existing-branch>` to resume/review an existing branch.
 4. If any command exits non-zero, stop and show the full error (and its `hint`). Do not retry automatically — branch on the exit code (below).
 5. Report that the CLI launched the agent, or show the error that prevented launch.
 
 ## Command reference
 
-- `create BRANCH` — provision and launch. Flags: `--base <branch>` `--checkout <existing-branch>` `--isolation host|docker` `--harness claude|codex` `--template <name>` `--cold` `--no-fetch` `--firewall/--no-firewall` `--dry-run` `--print` `--json` `--repo <path>` `--root <dir>` `--quiet` `--verbose`.
-- `enter BRANCH [-- AGENT_ARGS…]` — re-launch in an existing worktree; refreshes `.env`, re-syncs deps only if the lockfile changed. Flags: `--isolation` `--harness` `--template <name>` `--cold` `--print` `--json` `--repo` `--root` `--quiet` `--verbose`.
+- `create [NAME]` — provision and launch. Flags: `--base <branch>` `--checkout <existing-branch>` `--isolation host|docker` `--harness claude|codex` `--template <name>` `--cold` `--no-fetch` `--firewall/--no-firewall` `--dry-run` `--print` `--json` `--repo <path>` `--root <dir>` `--quiet` `--verbose`.
+- `enter REF [-- AGENT_ARGS…]` — re-launch in an existing worktree; refreshes `.env`, re-syncs deps only if the lockfile changed. Flags: `--isolation` `--harness` `--template <name>` `--cold` `--print` `--json` `--repo` `--root` `--quiet` `--verbose`.
 - `list` (alias `ls`) — table of worktrees (branch · isolation · deps freshness · `.env` presence · directory). Flags: `--repo` `--root` `--json`.
-- `teardown BRANCH` (alias `rm`) — remove the worktree; caches are left intact. Flags: `--force` `--delete-branch` `--remove-volumes` `--skip-container` `--json` `--isolation` `--repo` `--root` `--quiet` `--verbose`.
+- `teardown [REF...]` (alias `rm`) — remove selected worktrees; caches are left intact. Flags: `--force` `--delete-branch` `--remove-volumes` `--skip-container` `--json` `--isolation` `--repo` `--root` `--quiet` `--verbose`.
 - `doctor` — check git, login credentials, UID/GID, and isolation deps. Flags: `--isolation` `--repo` `--json`.
-- `version` / `--version` — print the version.
+- `version` / `--version` / `-V` — print the version.
 
 ## Examples
 
 ```bash
-treebox create feature/auth --base dev          # new branch from origin/dev, host isolation
-treebox create bugfix/docs --base dev --isolation docker
-treebox create hotfix/login --base main --cold  # ignore shared cache, from-source build
-treebox create feature/auth --harness codex        # Codex instead of Claude
-treebox create feature/auth --repo /path/to/repo
-treebox enter feature/auth                       # re-launch; refresh .env, re-sync deps if changed
-treebox enter feature/auth -- "continue the refactor"  # args after -- go to the agent verbatim
+treebox create fix-auth --base dev          # new placeholder from origin/dev, host isolation
+treebox create docs-fix --base dev --isolation docker
+treebox create hotfix-login --base main --cold  # ignore shared cache, from-source build
+treebox create fix-auth --harness codex        # Codex instead of Claude
+treebox create review-auth --checkout feature/auth  # exact existing branch
+treebox create fix-auth --repo /path/to/repo
+treebox enter fix-auth                       # re-launch; refresh .env, re-sync deps if changed
+treebox enter fix-auth -- "continue the refactor"  # args after -- go to the agent verbatim
 treebox list
-treebox teardown feature/auth --force
-treebox teardown feature/auth --force --delete-branch
+treebox teardown fix-auth --force
+treebox teardown fix-auth --force --delete-branch
 ```
 
 Provision without launching the agent (for scripting / over SSH / when you only need the worktree prepared):
 
 ```bash
-treebox create feature/auth --dry-run  # print the git/setup commands it would run; change nothing
-treebox create feature/auth --print    # prints the launch command (self-contained: carries the worktree dir, runnable from anywhere), no launch
-treebox create feature/auth --json     # JSON {schemaVersion, worktree_path, branch, base, entry_command, created}
+treebox create fix-auth --dry-run  # print the git/setup commands it would run; change nothing
+treebox create fix-auth --print    # prints the launch command (self-contained: carries the worktree dir, runnable from anywhere), no launch
+treebox create fix-auth --json     # JSON {schemaVersion, name, worktree_path, branch, base, entry_command, created}
 treebox list --json                     # JSON {schemaVersion, worktrees:[…]}
 treebox doctor --json                   # JSON health report; exits non-zero if a hard check fails
 ```
@@ -64,31 +65,32 @@ Branch on the **exit code**, not the text:
 | code | meaning |
 |------|---------|
 | `0` | success |
-| `2` | usage — bad branch name or option |
+| `1` | runtime failure, missing runner dependency, or failed doctor hard check |
+| `2` | usage — bad name/branch/config/ref or option |
 | `3` | not-found — the worktree the command needs doesn't exist |
 | `4` | auth/permission — `origin` fetch failed |
-| `5` | conflict — already exists / branch lock held / uncommitted changes |
+| `5` | conflict — already exists / worktree lock held / uncommitted changes |
 
-With `--json`, a failure prints **one object on stderr**: `{"schemaVersion":3,"error":{"code":"NOT_FOUND","message":"…","hint":"…"}}`. Read `error.code`, surface `error.hint`. Every JSON payload carries `schemaVersion` and only gains fields within a version (don't assume a fixed key set).
+With `--json`, a failure prints **one object on stderr**: `{"schemaVersion":3,"error":{"code":"NOT_FOUND","message":"…","hint":"…"}}`; `path` may also appear for path-specific failures such as `DIRTY_WORKTREE`. Read `error.code`, surface `error.hint`. Every JSON payload carries `schemaVersion` and only gains fields within a version (don't reject extra keys).
 
 ## Usage tips
 
 - **Default base is `main`** (configurable). A new branch created without `--base` is cut from `origin/main`; pass `--base <trunk>` when the repo's trunk is `master`, `dev`, etc.
 - Ask before using `--delete-branch` or `--remove-volumes`. Defaults keep both.
-- Branch names may include slashes. The CLI keeps the Git branch name but flattens slashes to `--` for the directory: `feature/auth` → `<root>/feature--auth` (default `<root>` = `.treebox/worktrees` under the repo; override with `--root`).
-- `create` launches the agent (Claude by default) after provisioning. Use `--harness codex`, or `--print` / `--json` / `--dry-run` to avoid launching.
-- `create` is **idempotent**: re-running it on a fully-provisioned worktree reports it and exits `0` (`created: false` in `--json`), not an error. Use `enter` to re-launch an existing one. If the dir exists but setup never finished (a prior run died mid-provision), `create` resumes setup instead of launching into a half-built tree.
+- `create NAME` accepts one lowercase slug; branch names with slashes belong in `--checkout` or as refs to `enter`/`teardown`. `create --checkout feature/auth` keeps the Git branch name but derives the directory name as `feature--auth` unless you pass `NAME` explicitly (default `<root>` = `.treebox/worktrees` under the repo; override with `--root`).
+- `create` launches the agent (Claude by default) after provisioning and exits with the agent process's exit code. Use `--harness codex`, or `--print` / `--json` / `--dry-run` to avoid launching.
+- Re-running `create` on a fully provisioned same-name worktree is a `SLUG_CONFLICT` (exit `5`), not an idempotent enter. Use `enter` to re-launch. If the dir exists but setup never finished (a prior run died mid-provision), `create` resumes setup instead of launching into a half-built tree.
 - **Freshness is enforced.** `create` *requires* a successful `git fetch origin` and branches from the freshly-fetched `origin/<base>` (preferred over a stale local branch). If the fetch fails it exits `4` and does **not** fall back to stale refs. In a terminal, git/ssh will prompt for credentials (no pre-loaded ssh-agent needed); headless/`--json` runs need working non-interactive auth. Pass `--no-fetch` only when the user explicitly accepts possibly-stale local refs (e.g. offline). A repo with no `origin` skips the fetch. Run `doctor` to check origin reachability up front.
 - `enter` recomputes the dependency-manifest hash and re-syncs only when deps changed; it always refreshes `.env`. Pass extra agent args after `--`. `--cold` bypasses the shared cache.
 - `--cold` is the escape hatch for a corrupted cache: from-source dependency resolution.
-- `teardown` confirms interactively. Without a TTY (scripts/agents) or with `--json` it refuses unless `--force` (exit `5`); `--force` is also required to remove a worktree with uncommitted changes. `--json` prints a record of what was removed to stdout. `--skip-container` leaves containers/images alone. With host isolation there are no containers/volumes to remove.
-- Only one `create`/`enter` may provision a given branch at a time (a per-branch lock, exit `5` if held). Wait rather than retrying immediately.
-- Output: a compact spinner + green checkmarks with right-aligned timings on stderr, degrading gracefully off-TTY and under `NO_COLOR` (no color/animation). `--verbose` streams raw command output; `--quiet` suppresses progress. `--json`/`--print`/`--dry-run` write machine output to stdout.
+- `teardown` confirms interactively. Without a TTY (scripts/agents) or with `--json` it refuses unless `--force` (exit `5`); `--force` is also required to remove a worktree with uncommitted changes. `--json` prints a record of what was removed to stdout. `--skip-container` leaves containers/images alone; cleanup failures are best-effort (`container: "failed"`) and do not undo worktree removal. With host isolation there are no containers/volumes to remove.
+- Only one `create`/`enter`/`teardown` may operate on a given worktree name at a time (a per-name lock, exit `5` if held). Wait rather than retrying immediately.
+- Output: a compact spinner + green checkmarks with right-aligned timings on stderr, degrading gracefully off-TTY and under `NO_COLOR` (no color/animation). `--verbose` streams raw command output; `--quiet` suppresses progress. `--json` success payloads and `--print` commands write to stdout; human `--dry-run` writes its plan to stderr, while `--dry-run --json` writes JSON to stdout.
 - The container firewall is off by default; pass `--firewall` to merge in the generated outbound allowlist. `--firewall`/`--no-firewall` is a tri-state override — an explicit flag wins in either direction and absence falls through to the `firewall` config default (so `--no-firewall` opts a single run out of a `firewall = true` config). The created-time choice is recorded, so `enter` reuses it rather than re-resolving the config.
 
 ## Notes
 
 - Authentication is **subscription-login only**: a one-time `claude` / `codex` login on the host (`~/.claude`, `~/.codex`) is reused everywhere. `doctor` verifies those dirs. `ANTHROPIC_API_KEY` is never used.
-- Defaults (`isolation`, `harness`, `base`, `root`, `env_file`, `firewall`, caches, custom setup hook) are configurable via a user-level TOML at `$TREEBOX_CONFIG`, else `~/.config/treebox/config.toml`. There is no repo-level config (a repo you don't trust must not run host commands).
-- The sandbox container is always defined by the operator template, never by anything in the target repo. Templates are named (`--template <name>`, default `default`): resolved from `$TREEBOX_TEMPLATE_DIR`, then `~/.config/treebox/templates/<name>/`, then the bundled default (only for `default`). An unknown name is a loud error, not a fallback. The rendered config + build context live *outside* the mounted worktree (`<root>/.containers/<branch>/`) and are never mounted in, so the boxed agent can't read or edit its own cage.
+- Defaults (`isolation`, `harness`, `base`, `root`, `env_file`, `firewall`, caches, custom setup hook) are configurable via a user-level TOML at `$TREEBOX_CONFIG`, else `$TREEBOX_HOME/config.toml` (default `~/.treebox/config.toml`). There is no repo-level config (a repo you don't trust must not run host commands).
+- The sandbox container is always defined by the operator template, never by anything in the target repo. Templates are named (`--template <name>`, default `default`): resolved from `$TREEBOX_TEMPLATE_DIR`, then `$TREEBOX_HOME/templates/<name>/` (default `~/.treebox/templates/<name>/`), then the bundled default (only for `default`). An unknown name is a loud error, not a fallback. The rendered config + build context live *outside* the mounted worktree (`<root>/.containers/<branch>/`) and are never mounted in, so the boxed agent can't read or edit its own cage.
 - Shared package caches live on the host and are reused across worktrees (and bind-mounted into containers), so a fresh worktree sets up at near warm-tree speed.

treebox-0.6.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to treebox will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+_Changes landing after the initial release will be recorded here._

{treebox-0.4.0 → treebox-0.6.0}/CLAUDE.md

@@ -2,8 +2,10 @@
 
 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 
-> `AGENTS.md` and `.agents/skills/` are symlinks. `CLAUDE.md` and `.claude/skills/`
-> are the sources of truth — edit those; the symlinks reflect changes automatically.
+> `AGENTS.md` symlinks to `CLAUDE.md`, and `.agents/skills/` symlinks to
+> `.claude/skills/`. The `treebox` skill's canonical copy lives in `skills/`
+> (kept there for users to copy-paste); `.claude/skills/treebox/` symlinks to it.
+> Edit the sources — `CLAUDE.md` and `skills/` — and the symlinks reflect the change.
 
 ## What this is
 
@@ -21,8 +23,8 @@ uv run --extra dev python -m pytest     # full unit + integration suite
 uv run --extra dev python -m pytest tests/test_units.py::test_name   # single test (or -k <pattern>)
 uv run --extra dev ruff check src tests # lint
 uv run --extra dev ruff format --check src tests   # format check (drop --check to apply)
-uv run --extra dev mypy                 # type check (config in pyproject.toml)
-uv run --extra dev pre-commit install   # install lint/format/type hooks (see CONTRIBUTING.md)
+uv run --extra dev mypy                 # strict type check (config in pyproject.toml)
+uv run --extra dev pre-commit install   # install lint/format/strict type-check hooks (see CONTRIBUTING.md)
 ./scripts/validate.sh                   # lint + format + tests + live host-runner smoke (real uv, throwaway local remote)
 uv pip install -e ".[dev]"              # editable dev environment
 uv run --extra docs mkdocs serve        # docs site (docs/ + mkdocs.yml), live-reloading
@@ -52,13 +54,13 @@ run (pluggable)**.
   git just works). `HARNESS_COMMANDS` maps `claude`/`codex` to their
   fully-autonomous launch argv.
 - **`cli.py`** (Typer) is the entry point: `create [NAME] / enter <ref> /
-  list / teardown <ref>... / doctor` (`ls`/`rm` are hidden aliases of
-  list/teardown). `enter`/`teardown` resolve a ref as
+  list / teardown <ref>... / doctor / version` (`ls`/`rm` are hidden aliases
+  of list/teardown). `enter`/`teardown` resolve a ref as
   name → live branch → unique substring (`resolve.py`); ambiguity exits 2.
-  It enforces **stable exit codes** (`0` ok · `2` usage · `3` not-found · `4`
-  auth/fetch · `5` conflict) and **`--json`** output carrying a
-  `schemaVersion` that only gains fields within a version — a breaking reshape
-  bumps it (git-porcelain discipline). Agents
+  It enforces **stable exit codes** (`0` ok · `1` runtime/doctor hard-check ·
+  `2` usage · `3` not-found · `4` auth/fetch · `5` conflict) and **`--json`**
+  output carrying a `schemaVersion` that only gains fields within a version —
+  a breaking reshape bumps it (git-porcelain discipline). Agents
   branch on these, so don't change their meanings casually.
 - **`ecosystems.py`** detects package managers (uv, npm, pnpm, go, cargo),
   drives their cache-backed setup, and defines which manifest files feed the
@@ -73,11 +75,14 @@ run (pluggable)**.
   with `git branch -m`). `create --checkout feature/auth` derives the name by
   flattening slashes to `--` (`feature--auth`); generated names come from
   `names.py`.
-- **`config.py`** is **user-level TOML only**, never read from the target repo —
-  a repo-level config could run arbitrary host commands. Same principle in
-  **`assets.py`**: the sandbox template is operator-owned and rendered into
-  a host-side dir *beside* the worktree, never inside the mount, so a boxed agent
-  cannot edit the config that defines its own sandbox.
+- **`config.py`** is **user-level TOML only** (`$TREEBOX_CONFIG`, else
+  `$TREEBOX_HOME/config.toml`, default `~/.treebox/config.toml`), never read
+  from the target repo — a repo-level config could run arbitrary host commands.
+  Same principle in **`assets.py`**: templates resolve from
+  `$TREEBOX_TEMPLATE_DIR`, then `$TREEBOX_HOME/templates/<name>` (default
+  `~/.treebox/templates/<name>`), and the sandbox template is operator-owned
+  and rendered into a host-side dir *beside* the worktree, never inside the
+  mount, so a boxed agent cannot edit the config that defines its own sandbox.
 
 ## Invariants to preserve
 

{treebox-0.4.0 → treebox-0.6.0}/CONTRIBUTING.md

@@ -10,10 +10,12 @@ treebox is a small, one-maintainer project. Contributions are welcome, but the s
 
 For larger feature ideas, open an issue first so we can decide whether they fit the project.
 
+A good contribution has also had a fair round of review before it lands — by you, by an AI reviewer, or preferably both.
+
 ## Local checks
 
 Install the pre-commit hooks once so every commit is auto-formatted, lint-fixed,
-and type-checked (`ruff format`, `ruff check --fix`, and `mypy`):
+and type-checked in strict mode (`ruff format`, `ruff check --fix`, and `mypy`):
 
 ```bash
 uv run --extra dev pre-commit install
@@ -32,7 +34,8 @@ will have no reported checks and the PR will stall; the remedy is to push from
 the workflow using a PAT or GitHub App token stored as a repo secret (e.g.
 `AUTOFIX_TOKEN`) instead of `GITHUB_TOKEN`.
 
-For code changes, run the relevant checks before opening a PR:
+For code changes, run the relevant checks before opening a PR. Mypy runs in
+strict mode (configured in `pyproject.toml`):
 
 ```bash
 uv run --extra dev python -m pytest
@@ -49,4 +52,4 @@ uv run --extra docs mkdocs build --strict
 
 ## Boundaries
 
-Please preserve the basics: fresh refs by default, no trust in target-repo sandbox config, stable CLI output for scripts, and subscription-based agent auth.
+Please preserve the basics: fresh refs by default, no trust in target-repo sandbox config, and stable CLI output for scripts.

treebox-0.6.0/LICENSE

@@ -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.
+