@julioborges/gantry 0.1.0

package/.agents/skills/gantry/scripts/spec.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Validate a Spec's structure against its effective template."""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from common import repo_root, resolve_effective_template, resolve_heading_map  # noqa: E402
+
+HEADING_RE = re.compile(r"^##(?!#)[ \t]+(.+?)[ \t]*$", re.MULTILINE)
+SCENARIO_RE = re.compile(r"^[ \t]*Scenario:[ \t]*(.+?)[ \t]*$", re.MULTILINE)
+STEP_RE = re.compile(r"^[ \t]*(Given|When|Then|And|But)[ \t]+(.+?)[ \t]*$")
+PLACEHOLDER_RE = re.compile(r"<[^>\n]+>|YYYY-MM-DD")
+DESCRIPTIVE_PLACEHOLDER_RE = re.compile(r"<[A-Za-z0-9](?:[^>\n]*[ \t][^>\n]*)\S>")
+FENCE_RE = re.compile(r"^\s*(?:`{3,}|~{3,})(.*)$")
+
+
+def headings(text: str) -> list[str]:
+    """Return the document's level-two Markdown headings."""
+    outside_fences: list[str] = []
+    fenced = False
+    for line in text.splitlines(keepends=True):
+        if re.match(r"^\s*(?:`{3,}|~{3,})", line):
+            fenced = not fenced
+        elif not fenced:
+            outside_fences.append(line)
+    return [f"## {match.group(1)}" for match in HEADING_RE.finditer("".join(outside_fences))]
+
+
+def scenario_blocks(text: str) -> tuple[list[tuple[int, str]], list[list[tuple[int, str]]]]:
+    """Return unfenced and Gherkin-fenced lines with original line numbers."""
+    unfenced: list[tuple[int, str]] = []
+    gherkin_blocks: list[list[tuple[int, str]]] = []
+    current_block: list[tuple[int, str]] = []
+    fenced = False
+    gherkin = False
+    for line_number, line in enumerate(text.splitlines(), 1):
+        fence = FENCE_RE.match(line)
+        if fence:
+            if not fenced:
+                gherkin = fence.group(1).strip().casefold() == "gherkin"
+            else:
+                if gherkin:
+                    gherkin_blocks.append(current_block)
+                current_block = []
+                gherkin = False
+            fenced = not fenced
+        elif gherkin:
+            current_block.append((line_number, line))
+        elif not fenced:
+            unfenced.append((line_number, line))
+    if gherkin:
+        gherkin_blocks.append(current_block)
+    return unfenced, gherkin_blocks
+
+
+def scenario_matches(lines: list[tuple[int, str]]) -> list[tuple[int, re.Match[str]]]:
+    """Locate Scenario headers in one validation context."""
+    return [(index, match) for index, (_, line) in enumerate(lines) if (match := SCENARIO_RE.match(line))]
+
+
+def validate_scenario_block(
+    lines: list[tuple[int, str]], strict: bool
+) -> list[dict[str, object]]:
+    """Check the scenarios in one unfenced or Gherkin-fenced block."""
+    malformed: list[dict[str, object]] = []
+    matches = scenario_matches(lines)
+    for index, (start, match) in enumerate(matches):
+        end = matches[index + 1][0] if index + 1 < len(matches) else len(lines)
+        phase: str | None = None
+        errors: list[tuple[int, str]] = []
+        for line_number, line in lines[start + 1:end]:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+            step = STEP_RE.match(line)
+            if step is None:
+                if strict:
+                    errors.append((line_number, "Scenario contains invalid Gherkin line"))
+                continue
+
+            kind = step.group(1)
+            if kind == "Given":
+                if phase in {None, "given"}:
+                    phase = "given"
+                else:
+                    errors.append((line_number, "Given cannot follow When or Then"))
+            elif kind == "When":
+                if phase == "given":
+                    phase = "when"
+                else:
+                    errors.append((line_number, "When must follow Given and precede Then"))
+            elif kind == "Then":
+                if phase == "when":
+                    phase = "then"
+                else:
+                    errors.append((line_number, "Then must follow When"))
+            elif phase is None:
+                errors.append((line_number, "And or But must follow Given, When or Then"))
+
+        if phase != "then":
+            errors.append((lines[start][0], "Scenario must end with Then steps"))
+        for line_number, reason in errors:
+            malformed.append(
+                {
+                    "line": line_number,
+                    "scenario": match.group(1),
+                    "reason": reason,
+                }
+            )
+    return malformed
+
+
+def canonical_heading(heading: str, heading_map: dict[str, str]) -> str:
+    """Translate one declared equivalent heading to its template heading."""
+    if heading in heading_map:
+        return heading_map[heading]
+    lowered = heading.casefold()
+    for alias, canonical in heading_map.items():
+        if alias.casefold() == lowered:
+            return canonical
+    return heading
+
+
+def validate_scenarios(text: str, required: bool) -> list[dict[str, object]]:
+    """Check Gherkin-fenced scenarios for ordered Given, When and Then steps."""
+    _, gherkin_blocks = scenario_blocks(text)
+    if required and not any(scenario_matches(block) for block in gherkin_blocks):
+        return [{"line": None, "reason": "expected at least one Scenario with Given, When and Then steps"}]
+
+    return [
+        finding
+        for block in gherkin_blocks
+        for finding in validate_scenario_block(block, True)
+    ]
+
+
+def validate(spec: Path, root: Path) -> dict[str, object]:
+    """Produce every structural finding for one Spec."""
+    template = resolve_effective_template(root, "spec")
+    template_text = template.read_text(encoding="utf-8")
+    text = spec.read_text(encoding="utf-8")
+    required = headings(template_text)
+    heading_map = resolve_heading_map(root)
+    actual = headings(text)
+    present: list[dict[str, str]] = []
+    positions: list[tuple[str, int]] = []
+    missing: list[str] = []
+
+    for expected in required:
+        match = next(
+            (
+                (position, heading)
+                for position, heading in enumerate(actual)
+                if canonical_heading(heading, heading_map).casefold() == expected.casefold()
+            ),
+            None,
+        )
+        if match is None:
+            missing.append(expected)
+        else:
+            position, heading = match
+            present.append({"expected": expected, "actual": heading})
+            positions.append((expected, position))
+
+    out_of_order: list[dict[str, str]] = []
+    for (previous, previous_position), (current, current_position) in zip(positions, positions[1:]):
+        if current_position < previous_position:
+            out_of_order.append(
+                {
+                    "expected": current,
+                    "found_after": previous,
+                    "actual": next(item["actual"] for item in present if item["expected"] == current),
+                }
+            )
+
+    template_placeholders = set(PLACEHOLDER_RE.findall(template_text))
+    detects_descriptive_placeholders = any(
+        DESCRIPTIVE_PLACEHOLDER_RE.fullmatch(placeholder)
+        for placeholder in template_placeholders
+    )
+    placeholders = [
+        {"line": text[:match.start()].count("\n") + 1, "text": match.group(0)}
+        for match in PLACEHOLDER_RE.finditer(text)
+        if match.group(0) in template_placeholders
+        or (
+            detects_descriptive_placeholders
+            and DESCRIPTIVE_PLACEHOLDER_RE.fullmatch(match.group(0))
+        )
+    ]
+    malformed_scenarios = validate_scenarios(text, "Scenario:" in template_text)
+    valid = not any((missing, out_of_order, placeholders, malformed_scenarios))
+    return {
+        "spec": str(spec),
+        "template": str(template),
+        "required_headings": required,
+        "present": present,
+        "missing": missing,
+        "out_of_order": out_of_order,
+        "placeholders": placeholders,
+        "malformed_scenarios": malformed_scenarios,
+        "valid": valid,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true", help="validate the supplied Spec")
+    parser.add_argument("spec", nargs="?", help="Spec path")
+    parser.add_argument("--cwd", default=".", help="repository or worktree containing the policy")
+    parser.add_argument("--json", action="store_true", help="print machine-readable findings")
+    args = parser.parse_args()
+    if not args.check or not args.spec:
+        parser.print_usage(sys.stderr)
+        return 2
+
+    root = repo_root(Path(args.cwd))
+    spec = Path(args.spec)
+    spec = spec if spec.is_absolute() else root / spec
+    if not spec.is_file():
+        payload = {"spec": str(spec), "error": "Spec is not a readable file"}
+        if args.json:
+            print(json.dumps(payload, indent=2))
+        else:
+            print(f"Spec is not a readable file: {spec}", file=sys.stderr)
+        return 2
+
+    try:
+        payload = validate(spec.resolve(), root)
+    except (OSError, UnicodeError, ValueError) as exc:
+        payload = {"spec": str(spec), "error": str(exc)}
+        if args.json:
+            print(json.dumps(payload, indent=2))
+        else:
+            print(f"Spec cannot be validated: {exc}", file=sys.stderr)
+        return 2
+    if args.json:
+        print(json.dumps(payload, indent=2))
+    else:
+        print("valid" if payload["valid"] else "invalid")
+        for key in ("missing", "out_of_order", "placeholders", "malformed_scenarios"):
+            for finding in payload[key]:
+                print(f"{key}: {finding}")
+    return 0 if payload["valid"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.agents/skills/gantry/templates/issue.md

@@ -0,0 +1,32 @@
+# <Issue title>
+
+Type: issue
+Status: draft
+Slice: `<spec-slug>#NN`
+Spec: `<spec path>`
+Created: YYYY-MM-DD
+
+## Parent
+
+`<spec-slug>`
+
+## What to build
+
+<One complete, demonstrable behaviour.>
+
+### Files to read
+
+List every additional initial-context file here. Each item must be exactly one
+repository-relative path in a code span; only this list is counted in the context budget.
+
+- `<repository-relative-path>`
+
+## Acceptance criteria
+
+- [ ] <Observable behaviour with runnable proof.>
+
+## Blocked by
+
+- None
+
+## Comments

package/.agents/skills/gantry/templates/prd.md

@@ -0,0 +1,26 @@
+# Product Requirements: <product>
+
+Status: draft
+Created: YYYY-MM-DD
+
+## 1. Problem
+
+<Problem and evidence.>
+
+## 2. Principles
+
+1. <Principle that guides delivery.>
+
+## 3. Scope
+
+| In scope | Out of scope |
+|---|---|
+| <Delivery> | <Explicit exclusion> |
+
+## 4. Success measures
+
+- <Observable measure.>
+
+## 5. Risks and decisions
+
+- <Open decision or accepted risk.>

package/.agents/skills/gantry/templates/spec.md

@@ -0,0 +1,48 @@
+# Spec: <feature>
+
+Type: spec
+Status: draft
+Map: `ROADMAP.md` (spec NN)
+Source: <product source>
+Created: YYYY-MM-DD
+
+## Blueprint
+
+### Context
+
+<Problem, users and current state.>
+
+### Architecture
+
+<Boundaries, contracts and implementation shape.>
+
+### Constraints
+
+<Positive, measurable constraints.>
+
+## Contract
+
+### Definition of Done
+
+- [ ] <Observable delivery outcome.>
+
+### Regression Guardrails
+
+- <Behaviour that must remain true.>
+
+### Scenarios
+
+```gherkin
+Scenario: <observable behaviour>
+  Given <context>
+  When <action>
+  Then <outcome>
+```
+
+## Out of Scope
+
+- <Excluded work and reason.>
+
+## Changelog
+
+- YYYY-MM-DD — Initial draft.

package/.agents/skills/gantry-dashboard/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: gantry-dashboard
+description: Opens a read-only, loopback-only kanban dashboard that shows every Gantry Run across every execution unit of the current Git clone — one swimlane per Run, Issues placed in Ready, Plan, Implement, Review, Critic, Integrate, Done and Blocked columns. Use for "open the dashboard", "show me the runs", "is anything stuck", "which run is stale".
+---
+
+# Gantry Dashboard
+
+A local HTTP server that renders the Run log `runlog.py` already writes. It never decides
+anything and never writes anything: every route is a `GET`, and the page polls
+`GET /api/state` to redraw itself. No Issue, policy, Run log, branch or worktree can be
+changed from the dashboard.
+
+## Open the dashboard
+
+```
+python3 <skillDir>/../gantry/scripts/dashboard.py serve
+```
+
+- Binds `127.0.0.1` only; the script refuses any other `--host` value and exits non-zero
+  before opening a socket. There is no way to expose the dashboard beyond the local machine.
+- Defaults to port `4600`; pass `--port 0` for an OS-assigned ephemeral port (the script
+  prints the resolved `host`/`port`/`stateRoot` as one JSON line before it starts serving).
+- Reads Run logs from `~/.gantry/state/<unit-id>/runs/*.jsonl` by default (every worktree of
+  one clone shares that state root); pass `--state-root` to point at a different one, for
+  example when inspecting a fixture.
+- Open `http://127.0.0.1:<port>/` in a browser once the server is listening.
+
+## What you see
+
+- One swimlane per Run (`<repositoryRoot> — <run> [tier: …]`), across every execution unit
+  under the state root — a Run started from one clone shows next to a Run from another.
+- Each Issue card sits in the column matching its most recent `phase.started` phase, or
+  `Done`/`Blocked` once `issue.done`/`issue.blocked` is logged.
+- Card badges: branch or worktree, per-role models, correction budget (used/ceiling), elapsed
+  time in the current phase, and whether the Run is waiting on the operator.
+- A swimlane is marked stale when its last non-`policy.changed` event is older than the
+  `staleAfterSeconds` value recorded on that Run's own `run.started` event — the snapshot
+  taken when the Run started, never the repository's current policy and never a later
+  `policy.changed` event.
+
+## Verify it without a browser
+
+```
+python3 -m unittest tests/test_dashboard.py -v
+```
+
+The test module and `dashboard.py` both import only the Python standard library (`argparse`,
+`datetime`, `http.server`, `json`, `pathlib`, `threading`, `time`, `urllib`, plus the pack's
+own `runlog` module) — no third-party dependency is required to run either the server or its
+tests.
+
+## Stopping the server
+
+`Ctrl-C` in the terminal running `dashboard.py serve` stops it; nothing it does needs
+cleanup, because it never wrote anything.

package/.agents/skills/gantry-setup/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: gantry-setup
+description: Conversational repository setup. The sole writer of repository policy and its marked AGENTS.md section.
+---
+
+# Gantry Setup
+
+You are the sole conversational writer of repository policy.
+
+1. **Present Decisions**: Present each artifact, template, check, Git, and hook decision to the operator.
+   - For each decision, provide its benefit, trade-off, default, and confirmation.
+   - Preserves pack defaults when skipped.
+
+2. **Capabilities & Hooks**:
+   - Reads capability declarations (from `.agents/skills/gantry/capabilities/*.json`) to offer only supported hook choices.
+   - Enables recording by default.
+   - Asks before denial hooks.
+
+3. **Constraints**:
+   - Creates no engine, database, MCP service, or automatic cleanup.
+   - All setup-generated policy, prompts, and marked content must be English.
+
+4. **Applying the Policy**:
+   Once the operator confirms the settings, construct the JSON configuration and pipe it to `setup.py`:
+   
+   ```bash
+   python3 .agents/skills/gantry/scripts/setup.py --config '{...}'
+   ```
+   
+   The `setup.py` script renders the full proposed `.gantry/config.json` before writing, supports merge, overwrite, and abort for an existing policy, handles idempotent merging of the Claude Code hook fragment into `.claude/settings.json`, and adds or replaces only the marked Gantry section in `AGENTS.md`. Do not modify these files directly.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 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.