weftgate 0.1.0__tar.gz

weftgate-0.1.0/.env.example

@@ -0,0 +1,9 @@
+# Environment variables weftgate itself reads (documented here so `weftgate audit` on this
+# repo has a declaration source; every value is optional).
+WEFTGATE_CACHE=                 # index directory (default: ~/.cache/weftgate)
+WEFTGATE_ORACLES=               # comma-separated oracle names, overrides weftgate.toml
+WEFTGATE_BLOCK_ON=              # reject | review | never
+WEFTGATE_ENV_DECLARED_IN=       # comma-separated extra env declaration files
+WEFTGATE_STACK=                 # pin the detected stack, e.g. python,fastapi
+WEFTGATE_USER_CONFIG=           # explicit user config path
+WEFTGATE_LEDGER=                # 0 disables the blocked-changes ledger

weftgate-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.py[cod]
+.venv/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+*.sqlite
+*.sqlite-wal
+*.sqlite-shm
+dist/
+build/
+*.egg-info/
+.DS_Store
+.coverage
+.coverage.*
+htmlcov/
+.launch-metrics/

weftgate-0.1.0/.pre-commit-hooks.yaml

@@ -0,0 +1,25 @@
+# Use with https://pre-commit.com:
+#
+#   repos:
+#     - repo: https://github.com/Avinash-Amudala/weftgate
+#       rev: v0.1.0
+#       hooks:
+#         - id: weftgate-check
+#
+# The hook blocks a commit only on a REJECT verdict (a proven broken wire).
+- id: weftgate-check
+  name: weftgate check (env vars, imports, routes resolve)
+  description: Verify that the files being committed reference things that exist.
+  entry: weftgate check --format=github
+  language: python
+  types: [text]
+  pass_filenames: true
+  require_serial: true
+- id: weftgate-audit
+  name: weftgate audit (whole repo)
+  description: Sweep the repository for latent broken wires.
+  entry: weftgate audit --format=github
+  language: python
+  pass_filenames: false
+  always_run: true
+  stages: [manual]

weftgate-0.1.0/AGENTS.md

@@ -0,0 +1,183 @@
+# AGENTS.md: how to build weftgate
+
+This file is the contract for any coding agent (Claude Code, Codex, Cursor, Antigravity) implementing this repo. Read it fully before writing code. The complete design is in `docs/DESIGN.md`; this file is the how, that file is the what and why. `docs/ADDENDUM-context-and-memory.md` defines the later phases (the grounded-context surface and verified memory); read it too, but do not build those yet.
+
+Scope for now is v0.1: the verification gate only. The context and recall consumers in the addendum are v0.2 and v0.3 and must not be started until v0.1 is complete and green.
+
+## 0. First action: set up the environment
+
+Run this once before anything else. It creates a virtual environment and installs the tool plus all dev and optional dependencies, so you have a working build immediately.
+
+```bash
+bash scripts/bootstrap.sh
+```
+
+If `bootstrap.sh` is missing or fails, do the equivalent by hand:
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e ".[all,dev]"
+python -m weftgate.selftest
+```
+
+Everything you need is declared in `pyproject.toml` and `requirements-dev.txt`. If you find you need another open-source library while building, add it to the correct group in `pyproject.toml` (core stays minimal, heavy things go under an optional extra) and to `requirements-dev.txt` if it is only for development, then re-run the install. Do not add a dependency to the core group unless the tool cannot run without it.
+
+## 1. What you are building, in one sentence
+
+A verification gate that checks whether the code an agent produced connects correctly to the project's own relationships and contracts, delivered as an MCP server, an identical CLI, and hooks, extensible through an oracle plugin interface.
+
+## 2. The one invariant you must never break
+
+**Block only on a positive, machine-checkable falsehood.** Everything else is `REVIEW` or `UNVERIFIABLE`, never `REJECT`. A missing index, an unresolvable dynamic reference, an optional extra that is not installed, a claim derived from prose: all of these soften, they never block. A gate that false-blocks is uninstalled the same day. When you are unsure whether something should reject or review, it reviews.
+
+## 3. Coding standards
+
+- Python 3.10 or newer. Use `match`, modern typing (`list[str]`, `X | None`), and dataclasses.
+- Standard library first. The core (`types`, `config`, `registry`, `oracle`, `store`, `gate`, `change`, `suggest`, `honesty`, `cli`, `mcp_server`) must import nothing outside the standard library. Optional capability goes behind extras (`weftgate[treesitter]`, `weftgate[lsp]`, `weftgate[yaml]`) and must degrade to `UNVERIFIABLE` when the extra is absent, tested with the extra uninstalled.
+- No network calls in the core. Oracles that need the network are opt-in and clearly marked, and are never on the default path.
+- Deterministic. Same repo state and same input give the same findings, in a stable order. The eval harness depends on this.
+- Fully type-annotated. `mypy` and `ruff` must pass clean; they run in CI and in the pre-push check.
+- Every oracle ships with tests, including at least one true positive (a real broken edge it catches and rejects), one true negative (correct code it accepts), and one soft case (a dynamic reference it reviews rather than rejects).
+
+## 4. Repo layout
+
+```
+weftgate/
+  __init__.py
+  types.py            # Claim, Finding, GateResult, Change, Context, enums. The shared vocabulary.
+  config.py           # precedence load, stack detection, cache/db path resolution
+  store.py            # SQLite index: connect, meta, per-oracle namespaces, incremental sync
+  registry.py         # OracleAPI, discovery from entry points + config dotted paths
+  oracle.py           # the Oracle protocol and the base helpers
+  change.py           # parse file / patch / git diff into a Change
+  gate.py             # run oracles, collect findings, compute verdict
+  suggest.py          # bounded-Levenshtein + token did-you-mean, budget-capped
+  honesty.py          # claim-mode outcome verdicts (PROVEN/PLAUSIBLE/NOT_OBSERVED/CONTRADICTED)
+  cli.py              # the plain CLI; identical output to the MCP server
+  mcp_server.py       # stdio MCP server; thin wrapper over the same gate calls as the CLI
+  selftest.py         # offline end-to-end self-test, no external services
+  oracles/
+    __init__.py
+    env_vars.py       # Tier 0 reference oracle, fully implemented
+    imports_lockfile.py  # Tier 0 slopsquatting/import oracle
+    routes_fastapi.py    # Tier 0 first edge oracle (FastAPI)
+  eval/
+    __init__.py
+    mutate.py         # mutation harness
+    audit.py          # audit sweep over an existing repo
+tests/
+scripts/
+  bootstrap.sh
+  install-hooks.sh    # writes the Claude Code PreToolUse hook + git pre-commit
+.github/workflows/ci.yml
+docs/DESIGN.md
+weftgate.toml             # example config
+pyproject.toml
+requirements-dev.txt
+README.md
+LICENSE
+```
+
+## 5. The shared vocabulary (implement `types.py` first)
+
+Everything else depends on these. Get them stable before writing oracles.
+
+```python
+class Level(StrEnum):        # verdict level for one claim
+    ACCEPT = "accept"
+    REVIEW = "review"
+    REJECT = "reject"
+    UNVERIFIABLE = "unverifiable"
+
+@dataclass(frozen=True)
+class Location:
+    file: str
+    line: int = 0
+    col: int = 0
+
+@dataclass(frozen=True)
+class Claim:
+    kind: str                # e.g. "env_var", "route_handler", "import"
+    subject: str             # the referenced thing, e.g. "DATABASE_URL"
+    location: Location
+    attrs: dict = field(default_factory=dict)  # oracle-specific structured payload
+    hard: bool = True        # hard claims may REJECT; soft claims cap at REVIEW
+    source: str = "code"     # "code" (diff mode) or "assertion" (claim mode)
+
+@dataclass(frozen=True)
+class Finding:
+    claim: Claim
+    level: Level
+    reason: str
+    oracle: str
+    suggestions: tuple[str, ...] = ()
+
+@dataclass(frozen=True)
+class GateResult:
+    verdict: Level           # worst blocking-eligible level; UNVERIFIABLE never raises it
+    findings: tuple[Finding, ...]
+    stats: dict
+```
+
+`GateResult.verdict` is computed by `gate.py`: `REJECT` if any finding is `REJECT`, else `REVIEW` if any is `REVIEW`, else `ACCEPT`. `UNVERIFIABLE` findings are reported in `findings` and counted in `stats` but never change `verdict`.
+
+## 6. The oracle contract (how to add any oracle)
+
+An oracle is an object with `name`, `kinds`, `extract`, `check`, and optionally `build`, `sync`, `suggest`. See `oracle.py` for the protocol and `oracles/env_vars.py` for the fully worked reference. The checklist for a correct oracle:
+
+1. `check` returns `UNVERIFIABLE` (never `REJECT`) when its index is absent or its optional extra is not installed.
+2. `check` returns `REJECT` only on a proven absence, and attaches suggestions when it can.
+3. Dynamic, computed, or indirect references return `REVIEW`, not `REJECT`.
+4. `extract` returns `[]` cleanly when the change has nothing for this oracle.
+5. `build`/`sync` preserve valid index state across rebuilds and never leave a half-written index (write to a temp table or transaction, then swap).
+6. Ships with the three required tests (true positive, true negative, soft case).
+
+Register it in `oracles/__init__.py` and expose a `register(api)` if it is a distributable plugin.
+
+## 7. Definition of done, per component
+
+- `types.py`: dataclasses and enums exist, are frozen where shown, and are imported by everything else.
+- `store.py`: opens a per-repo SQLite db at the resolved cache path, holds a `meta` table with schema version and build commit, gives each oracle a namespaced place to write, and syncs incrementally against the recorded commit plus the working-tree diff. A no-op sync is under a second.
+- `registry.py`: discovers oracles from installed entry points and from config dotted paths, holds the enabled set, exposes `OracleAPI.register_oracle`.
+- `gate.py`: given a `Change` (diff mode) or a list of `Claim` (claim mode) and a `Context`, runs the enabled oracles, collects findings, computes the verdict, and returns a `GateResult`. Runs `sync` before checking.
+- The three oracles: each passes its three tests and the mutation harness detects its injected breakage.
+- `cli.py` and `mcp_server.py`: both call the same gate functions and produce the same findings for the same input. A test asserts their outputs match.
+- `honesty.py`: grades outcome claims; never returns `PROVEN` without a matching machine-checkable signal; a test proves it withholds `PROVEN` when evidence is absent.
+- `eval/mutate.py`: injects known breakage, is deterministic by seed, reports detected and blocked separately, counts no-suggestion as a miss.
+- `eval/audit.py`: sweeps a repo and reports latent broken edges, reusing the same oracle `check` paths as the gate.
+- `selftest.py`: runs the whole pipeline offline on a tiny fixture repo it creates in a temp dir, and exits non-zero on any regression.
+
+## 8. Build order (each phase is shippable and testable on its own)
+
+1. `types.py`, then `config.py`, then `store.py`. Prove `store` builds and syncs on a fixture repo.
+2. `oracle.py` and `registry.py`. Prove an oracle can register and be discovered.
+3. `oracles/env_vars.py` end to end, with its tests. This is the vertical slice that proves the whole spine works: extract from a change, check against an index, produce a finding with a suggestion.
+4. `change.py` and `gate.py`. Now a real diff produces a `GateResult`.
+5. `cli.py`, then `mcp_server.py` as a thin wrapper, with the output-parity test.
+6. `oracles/imports_lockfile.py` and `oracles/routes_fastapi.py` with their tests.
+7. `honesty.py` and claim mode wiring.
+8. `eval/mutate.py` and `eval/audit.py`.
+9. `selftest.py`, `scripts/install-hooks.sh`, the setup command, and the CI workflow.
+
+Do not start a phase until the previous phase's tests pass.
+
+## 9. How to run things
+
+```bash
+python -m weftgate.selftest            # offline end-to-end check, run this often
+python -m pytest -q                # unit tests
+ruff check . && mypy weftgate          # lint and types, must be clean
+weftgate check path/to/changed_file.py # diff-mode check of a file
+weftgate audit                         # sweep the current repo for latent broken edges
+weftgate eval mutate --seed 13         # mutation harness, reproducible
+python -m weftgate.mcp_server          # start the stdio MCP server
+```
+
+## 10. Guardrails, restated because they are load-bearing
+
+- Never block on anything but a proven falsehood. Re-read section 2.
+- Never return `PROVEN` for an outcome claim without machine-checkable evidence you could re-derive.
+- The CLI and the MCP server must never diverge in what they find. They call the same functions.
+- Incremental sync must never throw away still-valid index state, and must never leave a partially written index on failure.
+- Keep the core standard-library-only. Anything heavier is an optional extra that degrades to `UNVERIFIABLE`.
+- Determinism is not optional; the eval harness and CI depend on it.

weftgate-0.1.0/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to weftgate are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow SemVer.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-12
+
+The verification gate.
+
+### Added
+- Verified memory (the recall consumer, addendum A5) as an integration with mnemo: a
+  changed-node ledger every sync appends to, anchors with content hashes and the
+  grounding commit, re-checks that yield valid/stale/invalid, and weftgate's oracles as a
+  mnemo verification plugin. `weftgate memory anchor|check|changes` and the
+  `memory_anchor`, `memory_check`, `memory_changes` MCP tools. See docs/MEMORY.md.
+- Three Tier 0 oracles, standard library only: `env_vars` (reads vs declarations across
+  dotenv files, settings schemas, Dockerfile/compose, code defaults), `imports_lockfile`
+  (imports vs lockfiles and manifests for Python and Node, with import-name aliases,
+  tsconfig path aliases, monorepo and nested project roots), `routes_fastapi` (routes
+  vs handlers and `include_router` wiring, built statically with `ast`).
+- Diff mode (file, new content, unified diff, git working tree or staged) and claim
+  mode (structured claims, including route existence and outcome claims).
+- The honesty gate: outcome claims graded PROVEN / PLAUSIBLE / NOT_OBSERVED /
+  CONTRADICTED; never PROVEN without machine-checkable evidence; re-runs and probes
+  are opt-in and allowlisted.
+- Per-repo SQLite index with atomic per-oracle tables and incremental sync (git diff
+  plus untracked files, fingerprint fallback without git).
+- A CLI and a standard-library stdio MCP server with an output-parity test; a Claude
+  Code PreToolUse hook adapter; `weftgate setup` writing config, index, git pre-commit
+  hook, and MCP config for Claude Code, Cursor, and VS Code; a GitHub Action;
+  pre-commit hooks.
+- Measurement: a seeded mutation harness that reports detected, blocked, and
+  correctly suggested separately; an audit sweep; an offline self-test; field
+  results on six open-source repositories.
+- An oracle-authoring guide and a scaffold script.
+
+### Release hardening
+- Refresh reused sessions, detect worktree reverts, preserve indexes on failed rebuilds,
+  and isolate nested transactions with savepoints.
+- Review incomplete dependency metadata and dynamic route evidence; never use installed
+  dependency percentages as proof of absence.
+- Preserve original memory hashes, invalidate changed symbols and declarations, and
+  return a safe pagination cursor for the changed-node ledger.
+- Validate structured claims, escape GitHub annotation properties, count nested JUnit
+  failures, and prevent opt-in URL probes from following redirects.
+- Preserve existing hooks and refuse malformed agent configuration.
+- Pass Action inputs as process arguments; gate trusted PyPI publishing on the full CI
+  matrix and extract release notes without dropping their final line.
+- Add a reproducible captioned demo, release documentation, and an organic launch plan.
+
+### Verdict rules worth knowing
+- A verdict blocks only on a positive, machine-checkable falsehood. A missing index,
+  an uninstalled extra, a dynamic reference, a documentation snippet, a repo with no
+  declaration source, or a name absent from a manifest without a lockfile all soften
+  to review or unverifiable.

weftgate-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# Contributing
+
+The fastest way to help is to write an oracle for a stack weftgate does not cover yet.
+An oracle is one file. Scaffold it with `python scripts/new-oracle.py <name> --kind <kind>`
+(it writes the oracle and its four tests), read `docs/ORACLES.md`, use
+`weftgate/oracles/env_vars.py` as the worked reference, and follow the checklist in
+`AGENTS.md` section 6. Install the repo's own pre-push check once with
+`bash scripts/dev-hooks.sh`.
+
+## The rule that gets a PR merged or rejected
+
+An oracle blocks (`REJECT`) only on a proven, machine-checkable absence. Anything
+it cannot resolve (dynamic names, missing index, uninstalled extra) returns
+`REVIEW` or `UNVERIFIABLE`. A false block is the one bug we will not merge.
+
+## Every oracle ships with three tests
+
+- true positive: a real broken edge it catches and rejects
+- true negative: correct code it accepts
+- soft case: a dynamic reference it reviews rather than rejects
+
+See `tests/test_env_vars.py`.
+
+## Before you push
+
+```bash
+ruff check . && ruff format --check . && mypy weftgate && python -m weftgate.selftest && pytest -q
+```

weftgate-0.1.0/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 2026 Avinash Amudala
+
+   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.

weftgate-0.1.0/NOTICE

@@ -0,0 +1,4 @@
+weftgate
+Copyright 2026 Avinash Amudala
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).