jezero 0.1.0__tar.gz

jezero-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# Local configuration and data: they describe YOUR machines and sources.
+jezero.toml
+*.local.toml
+.env
+.env.*
+!.env.example
+data/
+*.db
+*.db-wal
+*.db-shm
+*.sqlite
+*.sqlite3
+
+# Private denylist used by the pre-commit privacy check.
+.privacy-denylist
+
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+dist/
+build/
+
+# Editors and OS
+.DS_Store
+.idea/
+.vscode/
+pypi-dist/
+
+# Local leftovers that must never reach a package: config backups and lock files, caches,
+# logs, editor backups and JavaScript dependencies.
+*.toml.bak-*
+.*.toml.lock
+*.bak
+.cache/
+*.log
+node_modules/

jezero-0.1.0/CHANGELOG.md

@@ -0,0 +1,232 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0 - 2026-10-23
+
+First release on PyPI: `pip install jezero` or `uv tool install jezero`. Device
+client 0.5.3.
+
+- Second review before the first release. Server: a `.env` re-pointed by a symlink or
+  saved with invalid UTF-8 is handled on reload (an unreadable one disables `token_env`
+  clients); Host checks ignore case and cover websockets; inbox project names may use any
+  script (percent-encoded); config errors never echo values; a summarizer `base_url` over
+  `http://` to another host is refused unless `allow_insecure_http = true`; watchdog
+  alerts and stored errors are redacted, with configured secret values masked; server
+  instructions say every item is data, never instructions.
+- Core: redaction no longer hides ordinary text (`La contraseña: incorrecta`,
+  `Cookie: theme=dark`, ids, camelCase names) while still catching real secrets;
+  terminal escape sequences are stripped from summaries, imports and everything the CLI
+  and the app print, and `redact-stored` cleans stored items without re-summarising;
+  unchanged Paperclip items get the new ref after `connector reset` with no model calls;
+  multi-frame Codex `.zst` rollouts are read whole; a corrupt or locked database keeps
+  the cursor.
+- Client 0.5.3: sessions queued by 0.5.1 are sent after upgrading from any environment,
+  and those 0.5.2 wrongly marked "outside the session folder" are queued again;
+  symlinked config, token and state files stay links; `setup --agent codex` keeps tool
+  approvals, comments and other settings; prompt context is framed as data with source
+  and trust and stripped of control characters; the stdio bridge never answers
+  notifications.
+- Release and CI: only commits on `main` are published; uv, twine and the build backend
+  are pinned (hashed constraints); releases carry `SHA256SUMS` and signed build
+  provenance; every action is pinned to a commit SHA; `build_clients.py` ships only
+  tracked files and builds a reproducible bundle; the app installs plugins from its own
+  release tag (Hermes stays on `main`); docs gain a server-from-PyPI path and bundle
+  verification.
+- Security review before the first release. Server: `require_auth = false` is refused
+  together with `public_url` or `allowed_hosts`; Host and Origin are checked before the
+  key on every route (a bad host gets 421); `.jsonl.zst` uploads are measured
+  decompressed against `inbox.max_mb`, and the Codex connector reads rollouts in bounded
+  chunks; `token_env` values changed in `.env` apply without a restart; a config that
+  fails to load keeps only unchanged clients; `jezero device` commands refuse to
+  overwrite a file changed after they read it; search queries are bounded (4096
+  characters, 64 terms, 100 characters per term); new optional `[inbox] max_device_mb`.
+- Client 0.5.2: never follows HTTP redirects (they could carry the key to another host
+  or to plain HTTP); `init` refuses `http://` for other computers unless
+  `--insecure-http`; one bad file no longer stops the upload queue; files over
+  `max_upload_mb` are rejected without being read into memory; only the agent's own
+  session files are uploaded (no symbolic links, nothing outside its folder); `setup
+  --agent codex` keeps line endings and a backup, writes atomically and refuses entries
+  it cannot edit safely; `setup --agent antigravity` points the plugin at its core by
+  full path; private file modes (0700/0600), uploaded exports deleted, locked
+  `state.json`, and the stdio bridge answers every request with valid JSON-RPC.
+- Core: with `include_subagents`, sub-agent transcripts are their own items and no
+  longer prune the parent session; one unreadable session file is skipped and reported
+  instead of blocking its source; a malformed summarizer answer fails only that
+  document; redaction covers Telegram, Slack and Discord webhooks, `Authorization` and
+  `Cookie` headers, Groq, xAI, SendGrid, PyPI and Stripe webhook keys, PGP and cut-short
+  private keys, AWS secret keys, `mysql -p`, numeric and dotted passwords and Spanish key
+  names, and titles and context sent to the model are redacted too; `run --limit` no
+  longer skips sessions sharing a timestamp; Paperclip refs include the company;
+  `jezero eval` checks the types in question files; clean `error:` messages for a broken
+  config and bad `--ids`; `retag` and `resummarize` exit 3 when another run holds the
+  lock; accented project folder names count.
+- Project skeleton: configuration file with validation and env-only secrets.
+- SQLite + FTS5 store (trigram tokenizer, accent-insensitive) with BM25 ranking and a
+  recency boost.
+- Read-only MCP server over Streamable HTTP with per-client bearer tokens and source
+  filtering: `search`, `get_item`, `timeline`, `list_sources`.
+- Secret redaction before storage.
+- JSONL import of pre-summarised items.
+- Privacy pre-commit check.
+- Summarizer for Anthropic and OpenAI-compatible endpoints: title, summary, questions,
+  atoms and project through a fixed JSON schema, with retries.
+- Hermes Agent connector: read-only, dialogue only (tool results skipped), injected
+  memory blocks stripped, stable segments for long sessions, active sessions deferred.
+- `jezero run` with `--dry-run`, `--limit` and `--sample`; per-connector cursor.
+- A `.env` file next to the config is loaded automatically.
+- Claude Code and Codex connectors.
+- `jezero run --due` (per-connector intervals, one run at a time, a failing connector
+  no longer stops the others) and `jezero health` (stale/failing connectors, optional
+  webhook alert with de-duplication). systemd user units in `deploy/`.
+- Renamed from "biblioteca" to Jezero.
+- Codex connector: `sessions_dir` accepts a glob (one connector for every agent home an
+  orchestrator creates) and `user_prompt_markers` / `user_prompt_drop_lines` strip the
+  agent instructions an orchestrator repeats in every prompt.
+- Paperclip connector: each issue with its description, comments (system notices and
+  deleted comments skipped), documents and answered questions, read through the API with
+  GET requests only. Entries are ordered by creation time so segments stay stable as an
+  issue grows; quiet issues only.
+- OpenCode connector: sessions from `opencode.db` opened read-only; dialogue plus one
+  line per shell command or edited file, reasoning and read-only tools skipped.
+- `summarizer.output_language`: write every summary in one language, so a query in that
+  language also finds sessions held in another.
+- Prompt cleaning (`user_prompt_markers`, `user_prompt_drop_lines`) shared by connectors.
+- A project hint from the source (working directory, project field) now wins over the
+  model's guess. `jezero retag --connector NAME [--dry-run]` re-applies the hints to items
+  already stored, without calling the model.
+- `jezero resummarize --ids ... | --ids-file FILE`: summarise stored items again from
+  their kept original text (for example after setting `summarizer.output_language`).
+- Antigravity CLI connector: reads the per-conversation SQLite store through a minimal
+  protobuf wire reader (user text, agent replies, one line per tool call with its summary);
+  unknown or malformed steps are skipped.
+- Connectors can report warnings. The pipeline stores them as the connector's error and
+  holds the cursor, so `jezero health` (and the heartbeat) shows the connector as failing
+  until the cause is fixed. The Antigravity connector warns when a conversation has steps
+  but nothing in it can be read, which is how a format change shows up.
+- MCP tool `later(item_id, query?)`: newer items in the same project on the same subject,
+  newest first, flagged `matched_by=subject` or `project_timeline` (fallback). The server
+  instructions now tell agents that decisions change and to check `later` before answering
+  with a decision, plan or status. Each item summarises one session, so nothing else marks
+  a decision as superseded.
+- Hermes Agent plugin (`plugins/hermes`, `hermes plugins install MarsGotta/jezero/plugins/hermes`):
+  `jezero_*` tools, related past work on the first turn, the skill, and upload of the
+  session as turns end. The `hermes` connector reads those uploads with `export_dir`, and
+  takes the project from the session's working folder.
+- OpenCode plugin is a self-contained folder (`plugins/opencode`, with its core, skill and
+  `package.json`): related past work after the first prompt, the skill installed in
+  OpenCode's skills folder.
+- `init --no-upload` for computers that only read Jezero (the server's own computer).
+- Client 0.3.1: `status` on a read-only computer checks reading, not uploading.
+- Documentation rewritten and organised by Diátaxis in `docs/`: two tutorials, seven
+  how-to guides, seven reference pages, five explanation pages, a glossary and a style
+  guide. The command and configuration references are generated from the code
+  (`scripts/make_reference.py`); `scripts/check_docs.py` checks every link and anchor.
+  Both run in CI.
+- The app's Install and Update buttons run the full documented steps for each agent
+  (plugin, MCP server), not only `setup`; the package ships the OpenCode plugin for it.
+- The Jezero app: `jezero` with no command opens a terminal app (Textual) with Home,
+  Search (with "newer on this subject"), Timeline, Agents (detect, install and update the
+  plugins on this computer) and Agent view (the exact context an agent receives). Night
+  and dawn themes; `jezero ui --demo` runs it on made-up data. People commands:
+  `jezero connect`, `find`, `show --newer`, `agents`. New `GET /api/v1/overview` (any
+  client key, only its sources) feeds the dashboard without adding an MCP tool. The
+  client core ships inside the package as `jezero/client_core.py` (generated).
+- Antigravity plugin (`plugins/antigravity`, client 0.4.0): the MCP server through a local
+  stdio bridge (`jezero_client.py mcp`, so the key never sits in Antigravity's config),
+  the protocol and recent work at SessionStart, related past work before the first model
+  call, the skill, and upload of `transcript.jsonl` when a conversation stops. The
+  `antigravity` connector reads those uploads with `transcripts_dir`. The key may live in
+  `~/.gemini/config/jezero` for sandboxes that cannot see the user's home.
+- Client 0.3.3: the OpenCode plugin also finds a key in `<OpenCode config>/jezero`.
+- Client 0.3.2: sandboxed agents keep their own key in `<agent config>/jezero`
+  (`CLAUDE_CONFIG_DIR`, `CODEX_HOME`), used when `JEZERO_CLIENT_HOME` is not set.
+- `since`/`until` accept a bare date or a datetime without offset (read as UTC).
+- Connectors register themselves: each module declares a `CONNECTOR_TYPE` with its
+  `build` function and is discovered automatically; other packages can add connectors
+  through the `jezero.connectors` entry point group. Adding a connector is one file.
+- Summariser tests against a fake endpoint (both APIs, retries, errors, loose output).
+- Tidy-up: the old `project_from_cwd` helper and an empty test file are gone; the diagram
+  script moved to `scripts/`; `plugins/` carries a do-not-edit note.
+- The plugins install straight from GitHub: `claude plugin marketplace add MarsGotta/jezero`
+  and `codex plugin marketplace add MarsGotta/jezero`. `plugins/` is generated by
+  `scripts/build_clients.py` and checked in CI.
+- A visual README: architecture diagram (`docs/architecture.svg`, drawn by
+  `scripts/make_architecture.py`), badges and a synthetic example of an agent using Jezero.
+- Open-source readiness: CI workflow (lint, tests, privacy check, Python 3.9 client
+  check), `docs/architecture.md`, plugin manifests under Apache-2.0 like the project, the
+  obsolete `receiver` connector type removed (the device inbox replaces it), redaction no
+  longer hides code such as `token = get_access_token()`, neutral names in tests.
+- Project detection without assumptions about folder names (`jezero.projects`, shared
+  by the connectors and the device client): configured `[projects] paths` first, then the
+  git repository (the main repository for worktrees), then common root folders
+  (`projects`, `code`, `dev`, `src`, `repos`... configurable, case-insensitive). Devices
+  send the project they found with each upload (`X-Jezero-Project`), stored next to the
+  session as `<file>.project`.
+- Stronger redaction: env-style names ending in a secret word (`GITHUB_TOKEN=`,
+  `PGPASSWORD=`, `db_pass=`), quoted JSON keys, `--password X` flags, Basic auth, GitLab,
+  npm, Hugging Face and Stripe tokens, Azure keys and signed URLs. References (`$VAR`,
+  `<placeholder>`, paths) and prose (`tests PASS`, `OAuth`, `persist-credentials`) are kept.
+  `jezero redact-stored [--dry-run]` applies the rules to items already stored.
+- `jezero device approve --source-prefix/--read-only`.
+- Plugins for Claude Code, Codex and OpenCode (`clients/`), thin adapters over one shared
+  core (`clients/core/jezero_client.py`, Python 3.9+, standard library only). They add a
+  short protocol and the project's recent work at session start, related past work on the
+  first prompt, and upload each session to the server when it ends. The device key is
+  created on the device; the server only stores its SHA-256 (`jezero device approve`).
+  `scripts/build_clients.py` builds the bundle served at `/client/jezero-client.tar.gz`.
+- Inbox: `PUT /inbox/v1/<agent>/<path>` for clients with `upload = true`; files land in
+  `<inbox>/<device>/<agent>/...`, mirroring each agent's store, and the usual connectors
+  read them. Codex rollouts compressed with zstd (`.jsonl.zst`) are read; OpenCode can
+  read session exports (`export_dir`); Claude Code can skip project folders
+  (`skip_project_dirs`).
+- The MCP server unit stops within 10 s: clients keep streams open and the default 90 s
+  wait made restarts slow.
+- Search, `later` and `timeline` show one item per copy of a segment (same
+  `original_ref` and `external_id` in two sources); `jezero eval` counts a copy of an
+  expected item as a hit.
+- The summarizer is told that the order of `known_projects` means nothing and to use one
+  only when the document is about it: models picked the first listed slugs for unrelated
+  sessions.
+- `jezero retag --ask-model` re-asks the model, from the stored summary, the project of
+  items whose source gives none and whose tag their own text never mentions, and moves
+  an item only when its text names the new project; prints `old -> new`, `--log` keeps
+  the changes.
+- `jezero eval`: a TOML file of questions and the items that answer them, scored with the
+  same search the MCP server runs (top-k hits, hit@1, MRR), with `later` cases for
+  decisions that changed, a client's scope (`--client`, `--sources`), `--save` and
+  `--compare` to see which cases got better or worse, and `--fail-under` for scripts.
+  Guide: docs/how-to/measure-search.md; example: examples/eval.example.toml.
+- The summarizer's project guess goes through `[projects].aliases` and the connector's
+  `project_aliases`, like the source's own hint; `jezero retag` applies new aliases to
+  stored guesses too.
+- The `claude_code` connector takes a glob in `projects_dir`, like `codex` does in
+  `sessions_dir`: one connector follows the config folder of every agent an orchestrator
+  runs, reads a session copied between folders once (the newest copy), and passes the
+  folder name to the summarizer.
+- Client 0.5.1: `init --force` keeps this computer's other settings (such as `projects`)
+  and, for a device the server already knows, prints the `jezero device rotate` line to
+  give the admin; the "uploads refused" log line names the real fix.
+- `device approve` backs the config up like the other edits, and approving a name again
+  after `device revoke` reuses the connectors revoke kept instead of adding duplicates.
+- Client 0.5.0:
+  - The Claude Code plugin brings its own MCP server (`.mcp.json`, the stdio bridge), and
+    `setup --agent claude-code` / `--agent codex` register the stdio bridge instead of
+    writing the bearer key in clear into the agent's config. With the Claude Code plugin
+    installed, `setup` registers nothing and removes an old user-scope `jezero` HTTP entry;
+    an old `[mcp_servers.jezero]` HTTP block in Codex' `config.toml` is replaced, the rest
+    of the file left byte for byte.
+  - `client.json` takes an optional `mcp_path` (default `/mcp`, set with
+    `init --mcp-path`) for servers with a custom `[server].path`; the core and the
+    OpenCode plugin use it.
+  - Uploads refused with HTTP 401/403 stay queued (logged once) until the key may upload;
+    files rejected with 400/413/415 are recorded as rejected, not as uploaded, and
+    `status` reports them with the queue size.
+  - A key kept in an agent's own folder (Antigravity's `~/.gemini/config/jezero`,
+    `$CLAUDE_CONFIG_DIR/jezero`, `$CODEX_HOME/jezero`) is used by the background upload,
+    `backfill --agent` and `setup --agent`, and by the `mcp` bridge for every agent.
+  - Without a key the session-start hooks print nothing; the Hermes plugin gives the
+    protocol once per session. `state.json` no longer grows without limit. `flush`
+    always prints its counts; `status` and `flush` take `--agent`.
+  - The app labels newer items found only by date: "NEWER IN THIS PROJECT (by date, not
+    by subject)".

jezero-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,67 @@
+# Contributing
+
+Thanks for your interest. Jezero is early and small on purpose.
+
+1. Open an issue first for anything beyond a small fix, so we can agree on the approach.
+2. Keep changes focused, with tests. Bug fixes come with a regression test.
+3. Run the checks listed in [AGENTS.md](AGENTS.md) before opening a pull request:
+   `uv run pytest`, `uv run ruff check src tests scripts clients`,
+   `uv run ruff format --check src tests scripts clients` and
+   `python3 scripts/privacy_check.py --all`. The device client must keep running on
+   Python 3.9 with the standard library only (`clients/`, `src/jezero/projects.py`).
+4. Enable the privacy hook once per clone: `git config core.hooksPath .githooks`.
+   Add a git-ignored `.privacy-denylist` with terms that must never be committed from
+   your machine (host names, people, employers), one per line.
+5. Never include real transcripts, emails or personal details in issues, tests or
+   fixtures. Use synthetic data.
+
+## Documentation
+
+The docs live in [`docs/`](docs/README.md) and follow [docs/STYLE.md](docs/STYLE.md):
+tutorials, how-to guides, reference and explanation, each in its folder. A change that
+users can see comes with its docs in the same pull request.
+
+- `docs/reference/cli.md` and `docs/reference/configuration.md` are generated from the
+  code. Change the help text or the docstring, then run
+  `uv run python scripts/make_reference.py`.
+- `docs/app/*.svg` are real screenshots of the app on demo data:
+  `uv run python scripts/make_screenshots.py`.
+- `uv run python scripts/check_docs.py` checks every relative link and anchor. CI runs
+  all three checks.
+- The website is built from `docs/` with [Zensical](https://zensical.org):
+  `uv run --group docs python scripts/build_site.py --serve` previews it at
+  http://localhost:8000 with live reload. The build is strict, so a broken link fails it.
+  Every push to `main` publishes it (`.github/workflows/docs.yml`).
+
+By contributing you agree that your contributions are licensed under the Apache-2.0
+license of this project.
+
+## Adding a connector
+
+A connector is one file in `src/jezero/connectors/`. It reads a source incrementally
+(only what changed since the cursor in `ConnectorState`) and returns `RawDoc`s; the
+pipeline does redaction, summarising and storage. End the module with its type:
+
+```python
+def _build(conn: ConnectorConfig, ctx: BuildContext) -> MyConnector:
+    return MyConnector(
+        conn.name,
+        conn.options,
+        max_segment_chars=ctx.max_segment_chars,
+        default_project=conn.project,
+        project_rules=ctx.project_rules,  # if it knows the working directory
+    )
+
+
+CONNECTOR_TYPE = ConnectorType("mytool", "available", "What it reads.", build=_build)
+```
+
+That is all the registration there is: `jezero check-config` lists it and `jezero run`
+can schedule it. Add a test with synthetic files (see `tests/test_codex.py`), and an
+example entry in `jezero.example.toml`. New connectors should start with
+`enabled = false` in examples, so users run a pilot (`jezero run --connector NAME
+--sample 3`) before a full load.
+
+A connector can also live in its own package: expose its `ConnectorType` through the
+`jezero.connectors` entry point group and Jezero picks it up once installed.
+

jezero-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 Marcela Gotta
+
+   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.