aether-cache 0.1.0__tar.gz → 0.1.2__tar.gz

aether_cache-0.1.2/.gitignore

@@ -0,0 +1,21 @@
+*.jar
+!aether_cache/engine/aether-engine.jar
+target/
+.idea/
+src/main/java/embeddings_cache.npz
+__pycache__/
+*.egg-info/
+build/
+dist/
+
+# AI tool and design-hook config (Impeccable etc.), kept local
+.claude/
+.agent/
+.agents/
+.codex/
+.cursor/
+.gemini/
+.kiro/
+.impeccable/
+PRODUCT.md
+DESIGN.md

{aether_cache-0.1.0 → aether_cache-0.1.2}/PKG-INFO

@@ -1,14 +1,14 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: aether-cache
-Version: 0.1.0
+Version: 0.1.2
 Summary: Shared memory for AI coding tools that stays true to your code.
-Author: Anish Chugh
 Project-URL: Homepage, https://github.com/anishchugh05/Aether-Cache-Redis-Compatible-Vector-Store
+Author: Anish Chugh
 Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: mcp>=1.2
 Requires-Dist: fastembed>=0.3
+Requires-Dist: mcp>=1.2
 Requires-Dist: redis>=5.0
+Description-Content-Type: text/markdown
 
 [![progress-banner](https://backend.codecrafters.io/progress/redis/f43a7cd3-11e6-45dc-a8ba-9d6690c73ac0)](https://app.codecrafters.io/users/anishchugh05?r=2qF)
 
@@ -106,7 +106,7 @@ You need **Java 11+** (`brew install openjdk@21` on macOS, or [adoptium.net](htt
 Python for you. Then:
 
 ```sh
-uv tool install git+https://github.com/anishchugh05/Aether-Cache-Redis-Compatible-Vector-Store
+uv tool install aether-cache
 aether-cache setup
 ```
 
@@ -124,6 +124,8 @@ the engine only accepts connections from it, and your memories live in `~/.aethe
 | Command | What it does |
 |---|---|
 | `aether-cache setup` | One-time setup: engine, model, and AI tools |
+| `aether-cache add` | Adds the repo you're in (or a path) so the dashboard can check its files; the dashboard can also find and add repos for you |
+| `aether-cache ui` | Opens the dashboard: see what your AI remembers, and confirm or retire memories whose files changed |
 | `aether-cache status` | Is it running, and what's in this project's memory |
 | `aether-cache doctor` | Checks everything and tells you how to fix what's wrong |
 | `aether-cache list` / `recall "query"` / `explain m1` | Look at memories from the terminal |
@@ -322,7 +324,6 @@ Aether Cache is v1 and early. It works end to end in automated tests and is now
 - **A with-memory vs. without-memory evaluation** on real coding tasks, to measure whether it actually reduces
   re-explaining.
 - **AOF compaction:** the log only grows, and every status change adds a line.
-- **A dashboard** to browse, confirm, and retire memories in the browser.
 
 **Engine limitations:**
 - **Threading:** one OS thread per connection, not an event loop. That's fine for a local tool, but it won't scale to
@@ -346,8 +347,9 @@ aether_cache/                the Python package behind the `aether-cache` comman
   engine.py                  finds Java, starts and stops the engine in the background
   connect.py                 registers Aether Cache with Claude Code, Cursor, and Codex
   cli.py                     the `aether-cache` command
+  ui.py, ui/index.html       the dashboard (`aether-cache ui`): a local server, its API, and the page
   engine/aether-engine.jar   the prebuilt engine (rebuild with `python scripts/build_engine.py`)
 memory_mcp/calibrate.py      similarity calibration for duplicate/contradiction thresholds
 vector_bench.py              HNSW benchmark (writes results.json)
 crash_test.py                kill -9 crash-safety test
-```
+```

{aether_cache-0.1.0 → aether_cache-0.1.2}/README.md

@@ -94,7 +94,7 @@ You need **Java 11+** (`brew install openjdk@21` on macOS, or [adoptium.net](htt
 Python for you. Then:
 
 ```sh
-uv tool install git+https://github.com/anishchugh05/Aether-Cache-Redis-Compatible-Vector-Store
+uv tool install aether-cache
 aether-cache setup
 ```
 
@@ -112,6 +112,8 @@ the engine only accepts connections from it, and your memories live in `~/.aethe
 | Command | What it does |
 |---|---|
 | `aether-cache setup` | One-time setup: engine, model, and AI tools |
+| `aether-cache add` | Adds the repo you're in (or a path) so the dashboard can check its files; the dashboard can also find and add repos for you |
+| `aether-cache ui` | Opens the dashboard: see what your AI remembers, and confirm or retire memories whose files changed |
 | `aether-cache status` | Is it running, and what's in this project's memory |
 | `aether-cache doctor` | Checks everything and tells you how to fix what's wrong |
 | `aether-cache list` / `recall "query"` / `explain m1` | Look at memories from the terminal |
@@ -310,7 +312,6 @@ Aether Cache is v1 and early. It works end to end in automated tests and is now
 - **A with-memory vs. without-memory evaluation** on real coding tasks, to measure whether it actually reduces
   re-explaining.
 - **AOF compaction:** the log only grows, and every status change adds a line.
-- **A dashboard** to browse, confirm, and retire memories in the browser.
 
 **Engine limitations:**
 - **Threading:** one OS thread per connection, not an event loop. That's fine for a local tool, but it won't scale to
@@ -334,6 +335,7 @@ aether_cache/                the Python package behind the `aether-cache` comman
   engine.py                  finds Java, starts and stops the engine in the background
   connect.py                 registers Aether Cache with Claude Code, Cursor, and Codex
   cli.py                     the `aether-cache` command
+  ui.py, ui/index.html       the dashboard (`aether-cache ui`): a local server, its API, and the page
   engine/aether-engine.jar   the prebuilt engine (rebuild with `python scripts/build_engine.py`)
 memory_mcp/calibrate.py      similarity calibration for duplicate/contradiction thresholds
 vector_bench.py              HNSW benchmark (writes results.json)

{aether_cache-0.1.0 → aether_cache-0.1.2}/aether_cache/__init__.py

@@ -1,3 +1,3 @@
 """Aether Cache: shared memory for AI coding tools that stays true to your code."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

{aether_cache-0.1.0 → aether_cache-0.1.2}/aether_cache/cli.py

@@ -59,7 +59,7 @@ def cmd_setup(args) -> int:
           '  "Remember that our tests need DOCKER_HOST set. It depends on docker-compose.yml."\n'
           "Then, in a new session:\n"
           '  "How do I run the tests?"\n'
-          "\nCheck on things any time with `aether-cache status`.")
+          "\nSee and fix what your AI remembers any time with `aether-cache ui`.")
     return 0
 
 
@@ -179,6 +179,22 @@ def _tool_output(name: str, *tool_args) -> int:
     return 0
 
 
+def cmd_add(args) -> int:
+    from . import repos
+    from .server import EngineDown, store_down
+    try:
+        engine.ensure_running()
+        added = repos.add(args.path)
+    except repos.RepoError as e:
+        print(e)
+        return 1
+    except (engine.EngineError, EngineDown) as e:
+        print(store_down(e))
+        return 1
+    print(f"Added {added['name']} ({added['path']})" + (f", github.com/{added['github']}" if added["github"] else "") + ".")
+    return 0
+
+
 def cmd_serve(args) -> int:
     from .server import serve
     serve()
@@ -220,6 +236,13 @@ def main(argv=None) -> None:
         func=lambda a: _tool_output("sync_to_files"))
     sub.add_parser("check", help="retire memories whose linked files changed").set_defaults(
         func=lambda a: _tool_output("check_stale"))
+    p = sub.add_parser("add", help="add a repo so the dashboard can check its files (default: this folder)")
+    p.add_argument("path", nargs="?", default=".")
+    p.set_defaults(func=cmd_add)
+    p = sub.add_parser("ui", help="open the dashboard: see and fix what your AI tools remember")
+    p.add_argument("--port", type=int, help="port for the dashboard (default 7381)")
+    p.add_argument("--no-open", action="store_true", help="don't open a browser, just print the link")
+    p.set_defaults(func=lambda a: __import__("aether_cache.ui", fromlist=["serve"]).serve(a.port, not a.no_open))
     sub.add_parser("serve", help="run the MCP server (your AI tool runs this for you)").set_defaults(func=cmd_serve)
 
     args = parser.parse_args(argv)

{aether_cache-0.1.0 → aether_cache-0.1.2}/aether_cache/config.py

@@ -17,6 +17,7 @@ HOME = Path(_env("AETHER_HOME", default=str(Path.home() / ".aether-cache"))).exp
 DATA_DIR = HOME / "data"
 LOG_FILE = HOME / "engine.log"
 PID_FILE = HOME / "engine.pid"
+STAMP_FILE = HOME / "engine.version"  # which engine file the running engine was started from
 MODELS_DIR = HOME / "models"
 
 # The engine listens on this machine only. The port is deliberately not Redis's 6379, so Aether Cache

{aether_cache-0.1.0 → aether_cache-0.1.2}/aether_cache/engine.py

@@ -153,10 +153,36 @@ def _log_tail(lines: int = 15) -> str:
         return ""
 
 
+_fingerprint = None
+
+
+def jar_fingerprint() -> str:
+    """Identifies this version of the engine file, so a running engine from an older version can be spotted."""
+    global _fingerprint
+    if _fingerprint is None:
+        import hashlib
+        _fingerprint = hashlib.sha256(JAR.read_bytes()).hexdigest()[:16] if JAR.is_file() else ""
+    return _fingerprint
+
+
+def needs_upgrade() -> bool:
+    """True if the engine we started earlier came from a different engine file than this install's
+    (e.g. after `uv tool upgrade aether-cache`). Engines we didn't start are left alone."""
+    if running_pid() is None:
+        return False
+    try:
+        stamp = config.STAMP_FILE.read_text().strip()
+    except OSError:
+        stamp = ""  # started by a version from before stamps existed
+    return stamp != jar_fingerprint()
+
+
 def start(wait: float = 60) -> str:
-    """Starts the engine in the background (if it isn't already running) and waits until it answers."""
+    """Starts the engine in the background (if it isn't already running) and waits until it answers.
+    If the running engine is from an older install, restarts it on the new one (no data is lost:
+    every acknowledged write is already on disk)."""
     state = probe()
-    if state == "aether":
+    if state == "aether" and not needs_upgrade():
         return f"Engine already running on {config.HOST}:{config.PORT}."
     if state == "other":
         raise EngineError(port_taken_message())
@@ -166,10 +192,14 @@ def start(wait: float = 60) -> str:
     if not JAR.is_file():
         raise EngineError(f"The engine file is missing ({JAR}). Reinstall Aether Cache.")
 
+    upgraded = False
     with _start_lock():
         state = probe()  # another session may have started it while we waited for the lock
         if state == "aether":
-            return f"Engine already running on {config.HOST}:{config.PORT}."
+            if not needs_upgrade():
+                return f"Engine already running on {config.HOST}:{config.PORT}."
+            stop()
+            upgraded = True
         if state == "other":
             raise EngineError(port_taken_message())
         java, _ = find_java()
@@ -201,7 +231,9 @@ def start(wait: float = 60) -> str:
                                   + _log_tail())
             state = probe()
             if state == "aether":
-                started = f"Engine started on {config.HOST}:{config.PORT} (data in {config.DATA_DIR})."
+                config.STAMP_FILE.write_text(jar_fingerprint())
+                started = (f"Engine {'updated and restarted' if upgraded else 'started'} on {config.HOST}:{config.PORT} "
+                           f"(data in {config.DATA_DIR}).")
                 return f"{note}\n{started}" if note else started
             if state == "other":
                 process.terminate()
@@ -211,7 +243,7 @@ def start(wait: float = 60) -> str:
 
 
 def ensure_running() -> None:
-    if probe() != "aether":
+    if probe() != "aether" or needs_upgrade():
         start()
 
 

aether_cache-0.1.2/aether_cache/repos.py

@@ -0,0 +1,134 @@
+"""
+Finding and adding the git repos whose memories Aether Cache manages.
+
+Adding a repo just records where it lives (aether:repo:<project> -> folder), which lets the dashboard check
+its memories' files from anywhere. Nothing is read from the repo beyond git metadata; nothing leaves the machine.
+"""
+import os
+import platform
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import List, Optional
+
+from . import server
+
+# Where people usually keep code. Only these are searched, a few levels deep, and only when asked.
+SEARCH_ROOTS = ["Desktop", "Documents", "Projects", "projects", "Developer", "dev", "code", "Code", "src",
+                "repos", "git", "GitHub", "workspace", "work", "Sites"]
+SKIP = {"node_modules", "Library", "Applications", "venv", ".venv", "env", "__pycache__", "build", "dist", "target",
+        "vendor", "Pods", "DerivedData", ".Trash", "Pictures", "Music", "Movies", "Downloads"}
+MAX_DEPTH = 4
+MAX_RESULTS = 300
+TIME_BUDGET = 3.0  # seconds; a huge Documents folder shouldn't make the dashboard hang
+
+
+class RepoError(Exception):
+    pass
+
+
+def git_top(path: Path) -> Optional[Path]:
+    """The repo's top folder if path is inside a git repo, else None."""
+    try:
+        out = subprocess.run(["git", "rev-parse", "--show-toplevel"], cwd=path, capture_output=True, text=True, timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return Path(out.stdout.strip()) if out.returncode == 0 and out.stdout.strip() else None
+
+
+def github_remote(path: Path) -> Optional[str]:
+    """"owner/repo" if the repo's origin is on GitHub (read from local git config, no network), else None."""
+    try:
+        out = subprocess.run(["git", "config", "--get", "remote.origin.url"], cwd=path, capture_output=True, text=True, timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    m = re.search(r"github\.com[:/]([\w.-]+)/([\w.-]+?)(?:\.git)?/?$", out.stdout.strip())
+    return f"{m.group(1)}/{m.group(2)}" if m else None
+
+
+def discover() -> List[dict]:
+    """Git repos in the usual code folders under your home folder, newest first."""
+    home = Path.home()
+    roots = [home / r for r in SEARCH_ROOTS if (home / r).is_dir()]
+    found, seen = [], set()
+    deadline = time.monotonic() + TIME_BUDGET
+
+    def walk(folder: Path, depth: int) -> None:
+        if depth > MAX_DEPTH or len(found) >= MAX_RESULTS or time.monotonic() > deadline:
+            return
+        try:
+            entries = list(os.scandir(folder))
+        except OSError:
+            return  # no permission (e.g. macOS-protected folders); skip quietly
+        if any(e.name == ".git" for e in entries):
+            real = folder.resolve()
+            if real not in seen:
+                seen.add(real)
+                try:
+                    modified = (folder / ".git").stat().st_mtime
+                except OSError:
+                    modified = 0
+                found.append({"path": str(folder), "modified": modified})
+            return  # don't look for repos inside a repo
+        for e in entries:
+            if e.is_dir(follow_symlinks=False) and not e.name.startswith(".") and e.name not in SKIP:
+                walk(Path(e.path), depth + 1)
+
+    for root in roots:
+        walk(root, 1)
+    found.sort(key=lambda r: -r["modified"])
+    for r in found:
+        r["name"] = Path(r["path"]).name
+        r["github"] = github_remote(Path(r["path"]))
+    return found
+
+
+def add(path: str) -> dict:
+    """Adds a project by folder (for a git repo, any folder inside it works). Returns {name, path, github}."""
+    folder = Path(path).expanduser()
+    if not folder.is_dir():
+        raise RepoError(f"{path} isn't a folder.")
+    # A git repo is added by its top folder (so memories match from any subfolder). A plain folder works too:
+    # file fingerprints don't need git, and the AI tools treat a non-git folder as a project named after it.
+    top = git_top(folder) or folder.resolve()
+    name = top.name
+    existing = server.db().get(server.REPO_KEY + name)
+    if existing and Path(existing).resolve() != top.resolve() and Path(existing).is_dir():
+        raise RepoError(f"A different repo with the same folder name, {name}, is already added ({existing}). "
+                        f"Projects are named after their folder, so rename one of the folders to keep both.")
+    server.db().set(server.REPO_KEY + name, str(top))
+    return {"name": name, "path": str(top), "github": github_remote(top)}
+
+
+def remove(name: str) -> None:
+    """Forgets where a repo lives. Its memories are kept; it just stops being listed if it has none."""
+    server.db().set(server.REPO_KEY + name, "")  # the engine has no DEL; an empty location means "not added"
+
+
+def pick_folder() -> Optional[str]:
+    """Opens this computer's own folder picker and returns the chosen path, or None if cancelled.
+    Raises RepoError if there's no picker available (then the user can type a path instead)."""
+    system = platform.system()
+    if system == "Darwin":
+        # "tell me to activate" brings the picker to the front without asking to control another app
+        script = ('tell me to activate\n'
+                  'POSIX path of (choose folder with prompt "Choose a project folder to add to Aether Cache")')
+        cmd = ["osascript", "-e", script]
+    elif system == "Windows":
+        ps = ("Add-Type -AssemblyName System.Windows.Forms; $d = New-Object System.Windows.Forms.FolderBrowserDialog; "
+              "$d.Description = 'Choose a git repo to add to Aether Cache'; "
+              "if ($d.ShowDialog() -eq 'OK') { $d.SelectedPath }")
+        cmd = ["powershell", "-NoProfile", "-Command", ps]
+    else:
+        cmd = ["zenity", "--file-selection", "--directory", "--title=Choose a git repo to add to Aether Cache"]
+    try:
+        out = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+    except FileNotFoundError:
+        raise RepoError("This computer has no folder picker available. Paste the folder's path instead.")
+    except subprocess.TimeoutExpired:
+        return None
+    if out.returncode != 0:  # cancelled
+        return None
+    chosen = out.stdout.strip()
+    return (chosen.rstrip("/\\") or chosen) or None

{aether_cache-0.1.0 → aether_cache-0.1.2}/aether_cache/server.py

@@ -170,9 +170,28 @@ def git_toplevel() -> Optional[Path]:
     return None
 
 
+REPO_KEY = "aether:repo:"  # aether:repo:<project> -> the repo's folder, so the dashboard can check its files
+_registered = set()
+
+
 def project_name() -> str:
     """The project memories belong to: AETHER_PROJECT, else the git repo's folder name, else this folder's."""
-    return config.project_override() or (git_toplevel() or workdir()).name
+    name = config.project_override() or (git_toplevel() or workdir()).name
+    _remember_repo_location(name)
+    return name
+
+
+def _remember_repo_location(project: str) -> None:
+    """Records where this project's repo lives (once per session), so `aether-cache ui`, which runs
+    from anywhere, can still check its memories' files. Best effort: never gets in the AI's way."""
+    top = git_toplevel()
+    if top is None or (project, str(top)) in _registered:
+        return
+    _registered.add((project, str(top)))
+    try:
+        db().set(REPO_KEY + project, str(top))
+    except Exception:
+        _registered.discard((project, str(top)))
 
 
 def repo_root() -> Path:
@@ -180,12 +199,12 @@ def repo_root() -> Path:
     return git_toplevel() or workdir()
 
 
-def relative(path: str) -> str:
+def relative(path: str, root: Optional[Path] = None) -> str:
     """Makes a path repo-relative, so memories still match if the repo is opened from a subfolder."""
     p = Path(path.strip())
     if p.is_absolute():
         try:
-            return p.resolve().relative_to(repo_root().resolve()).as_posix()
+            return p.resolve().relative_to((root or repo_root()).resolve()).as_posix()
         except ValueError:
             return str(p)
     return p.as_posix()
@@ -197,9 +216,9 @@ def blob_hash(path: Path) -> str:
     return hashlib.sha1(b"blob %d\0" % len(data) + data).hexdigest()
 
 
-def content_hashes(paths: List[str]) -> dict:
+def content_hashes(paths: List[str], root: Optional[Path] = None) -> dict:
     """path -> hash of the file's current contents, or "missing"."""
-    root = repo_root()
+    root = root or repo_root()
     result = {}
     for p in paths:
         try:
@@ -209,25 +228,28 @@ def content_hashes(paths: List[str]) -> dict:
     return result
 
 
-def link_files(paths: List[str]) -> str:
+def link_files(paths: List[str], root: Optional[Path] = None) -> str:
     """["a.py", "b.yml"] -> "a.py@<hash>,b.yml@<hash>": the files plus a snapshot of their contents."""
-    rel = [relative(p) for p in paths if p.strip()]
-    hashes = content_hashes(rel)
+    root = root or repo_root()
+    rel = [relative(p, root) for p in paths if p.strip()]
+    hashes = content_hashes(rel, root)
     return ",".join(f"{p}@{hashes[p]}" for p in rel)
 
 
-def check_staleness() -> List[str]:
+def check_staleness(project: Optional[str] = None, root: Optional[Path] = None) -> List[str]:
     """Marks active memories stale when a file they depend on has changed since they were saved.
-    Returns one line per memory that just went stale."""
+    Returns one line per memory that just went stale. Defaults to the current project and repo."""
+    project = project or project_name()
+    root = root or repo_root()
     newly_stale = []
     linked = []  # (id, text, [(path, saved hash)])
-    for mid, _status, files, text in run("MEM.LIST", project_name()):
+    for mid, _status, files, text in run("MEM.LIST", project):
         entries = [f.rsplit("@", 1) for f in files.split(",") if "@" in f]
         if entries:
             linked.append((mid, text, entries))
     if not linked:
         return newly_stale
-    current = content_hashes(sorted({path for _, _, entries in linked for path, _ in entries}))
+    current = content_hashes(sorted({path for _, _, entries in linked for path, _ in entries}), root)
     for mid, text, entries in linked:
         changed = [path for path, saved in entries if current.get(path) != saved]
         if changed:
@@ -237,6 +259,19 @@ def check_staleness() -> List[str]:
     return newly_stale
 
 
+def confirm(memory_id: str, root: Optional[Path] = None) -> Optional[bool]:
+    """Marks a memory still true and re-links it to the current versions of its files.
+    Returns whether it has linked files, or None if there's no such memory."""
+    r = run("MEM.GET", memory_id)
+    if r is None:
+        return None
+    files = [f.rsplit("@", 1)[0] for f in dict(zip(r[0::2], r[1::2]))["files"].split(",") if f]
+    if files:
+        run("MEM.FILES", memory_id, link_files(files, root), "REASON", "confirmed still true")
+    run("MEM.STATUS", memory_id, "active", "REASON", "confirmed still true")
+    return bool(files)
+
+
 # ---------- tools the AI can call ----------
 
 @mcp.tool()
@@ -363,16 +398,12 @@ def confirm_memory(memory_id: str) -> str:
     """Mark a memory as still true (e.g. after it was retired because a linked file changed, but the
     fact itself didn't). Re-links it to the current version of its files."""
     try:
-        r = run("MEM.GET", memory_id)
-        if r is None:
-            return f"No memory with id {memory_id}."
-        files = [f.rsplit("@", 1)[0] for f in dict(zip(r[0::2], r[1::2]))["files"].split(",") if f]
-        if files:
-            run("MEM.FILES", memory_id, link_files(files), "REASON", "confirmed still true")
-        run("MEM.STATUS", memory_id, "active", "REASON", "confirmed still true")
+        linked = confirm(memory_id)
     except EngineDown as e:
         return store_down(e)
-    return f"Confirmed {memory_id}; it's active again" + (" and linked to the current file versions." if files else ".")
+    if linked is None:
+        return f"No memory with id {memory_id}."
+    return f"Confirmed {memory_id}; it's active again" + (" and linked to the current file versions." if linked else ".")
 
 
 # ---------- syncing to AGENTS.md / CLAUDE.md ----------

aether_cache-0.1.2/aether_cache/ui/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2019 IBM Corp. All rights reserved. IBMPlexSans-Italic[wdth,wght].ttf: Copyright 2019 IBM Corp. All rights reserved.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.