mnemonics 0.1.0__py3-none-any.whl

mnemonics/__init__.py

@@ -0,0 +1,7 @@
+"""mnemonics — verified AI memory. Retrieval that doesn't hallucinate."""
+from mnemonics.store import Store
+from mnemonics.ingest import ingest
+from mnemonics.retrieve import retrieve
+
+__all__ = ["Store", "ingest", "retrieve"]
+__version__ = "0.1.0"

mnemonics/cli.py

@@ -0,0 +1,82 @@
+"""mnemonics CLI."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(prog="mnemonics")
+    sub = p.add_subparsers(dest="cmd")
+
+    # serve
+    s = sub.add_parser("serve", help="Start REST server")
+    s.add_argument("--port", type=int, default=7810)
+    s.add_argument("--path", default="~/.mnemonics")
+
+    # mcp
+    sub.add_parser("mcp", help="Start MCP stdio server")
+
+    # ingest
+    i = sub.add_parser("ingest", help="Add text to memory")
+    i.add_argument("text", nargs="+")
+    i.add_argument("--ns", default="default")
+    i.add_argument("--path", default="~/.mnemonics")
+
+    # retrieve
+    r = sub.add_parser("retrieve", help="Search memory")
+    r.add_argument("query")
+    r.add_argument("--ns", default="default")
+    r.add_argument("--top-k", type=int, default=5)
+    r.add_argument("--no-verify", action="store_true")
+    r.add_argument("--path", default="~/.mnemonics")
+
+    # stats
+    st = sub.add_parser("stats", help="Show memory stats")
+    st.add_argument("--path", default="~/.mnemonics")
+
+    args = p.parse_args()
+
+    if args.cmd == "serve":
+        import os
+        os.environ["MNEMONICS_PATH"] = args.path
+        from mnemonics.server import serve
+        serve(port=args.port)
+
+    elif args.cmd == "mcp":
+        from mnemonics.server import serve
+        serve(mcp=True)
+
+    elif args.cmd == "ingest":
+        from mnemonics.store import Store
+        from mnemonics.ingest import ingest
+        store = Store(args.path)
+        n = ingest(texts=[" ".join(args.text)], store=store, ns=args.ns)
+        print(f"Stored {n} chunk(s).")
+
+    elif args.cmd == "retrieve":
+        from mnemonics.store import Store
+        from mnemonics.retrieve import retrieve
+        store = Store(args.path)
+        result = retrieve(
+            query=args.query,
+            store=store,
+            ns=args.ns,
+            top_k=args.top_k,
+            verify=not args.no_verify,
+        )
+        print(f"trust_score: {result['trust_score']}  flagged: {result['flagged_count']}")
+        for r in result["results"]:
+            flag = " ⚠" if r.get("flagged") else ""
+            print(f"  [{r['score']:.3f}]{flag} {r['text'][:120]}")
+
+    elif args.cmd == "stats":
+        from mnemonics.store import Store
+        store = Store(args.path)
+        for ns in store.list_namespaces():
+            print(f"  {ns}: {store.count(ns)} chunks")
+
+    else:
+        p.print_help()
+        sys.exit(1)

mnemonics/ingest.py

@@ -0,0 +1,63 @@
+"""Ingest text into the store: chunk → embed → save."""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import numpy as np
+
+from mnemonics.store import Store
+
+_encoder: Any = None
+_encoder_name: str = "all-MiniLM-L6-v2"
+
+
+def _get_encoder(model: str = _encoder_name) -> Any:
+    global _encoder, _encoder_name
+    if _encoder is None or model != _encoder_name:
+        from sentence_transformers import SentenceTransformer
+        _encoder = SentenceTransformer(model)
+        _encoder_name = model
+    return _encoder
+
+
+def _chunk(text: str, size: int = 200, overlap: int = 40) -> list[str]:
+    words = text.split()
+    if len(words) <= size:
+        return [text]
+    chunks = []
+    i = 0
+    while i < len(words):
+        chunk = " ".join(words[i:i + size])
+        chunks.append(chunk)
+        i += size - overlap
+    return chunks
+
+
+def ingest(
+    texts: list[str],
+    store: Store,
+    ns: str = "default",
+    meta: list[dict] | None = None,
+    model: str = "all-MiniLM-L6-v2",
+    chunk_size: int = 200,
+    chunk_overlap: int = 40,
+) -> int:
+    """Chunk, embed and store texts. Returns total chunks stored."""
+    enc = _get_encoder(model)
+    all_chunks: list[str] = []
+    all_meta: list[dict] = []
+
+    for i, text in enumerate(texts):
+        chunks = _chunk(text, chunk_size, chunk_overlap)
+        m = (meta[i] if meta else {}) | {"source_idx": i}
+        all_chunks.extend(chunks)
+        all_meta.extend([m] * len(chunks))
+
+    if not all_chunks:
+        return 0
+
+    vecs = enc.encode(all_chunks, batch_size=64, show_progress_bar=False,
+                      normalize_embeddings=True, convert_to_numpy=True)
+    store.add(all_chunks, vecs, ns=ns, meta=all_meta)
+    return len(all_chunks)

mnemonics/retrieve.py

@@ -0,0 +1,66 @@
+"""Retrieve memories — embed query, search, optionally verify with halluguard."""
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+from mnemonics.store import Store
+from mnemonics.ingest import _get_encoder
+
+
+def retrieve(
+    query: str,
+    store: Store,
+    ns: str = "default",
+    top_k: int = 5,
+    model: str = "all-MiniLM-L6-v2",
+    verify: bool = True,
+    verify_threshold: float = 0.45,
+) -> dict[str, Any]:
+    """
+    Search the store for query.
+    If verify=True, runs halluguard on results against the retrieved corpus.
+    Returns: {results, verified, trust_score, flagged_count}
+    """
+    enc = _get_encoder(model)
+    qvec = enc.encode([query], normalize_embeddings=True, convert_to_numpy=True)[0]
+    results = store.search(qvec, ns=ns, top_k=top_k)
+
+    if not results:
+        return {"results": [], "verified": True, "trust_score": 1.0, "flagged_count": 0}
+
+    trust_score = 1.0
+    flagged_count = 0
+    verified = True
+
+    if verify:
+        try:
+            corpus = [r["text"] for r in results]
+            combined = " ".join(corpus)
+            resp = requests.post(
+                "http://127.0.0.1:7801/check",
+                json={"corpus": corpus, "answer": combined, "threshold": verify_threshold},
+                timeout=10,
+            )
+            if resp.ok:
+                data = resp.json()
+                trust_score = data.get("trust_score", 1.0)
+                flagged_count = data.get("n_flagged", 0)
+                verified = data.get("ok", True)
+                # Mark flagged results
+                flagged_texts = {f["text"] for f in data.get("flagged", [])}
+                for r in results:
+                    r["flagged"] = r["text"] in flagged_texts
+        except Exception:
+            pass  # halluguard daemon not running — skip verify
+
+    for r in results:
+        r.setdefault("flagged", False)
+
+    return {
+        "results": results,
+        "verified": verified,
+        "trust_score": round(trust_score, 4),
+        "flagged_count": flagged_count,
+    }

mnemonics/server.py

@@ -0,0 +1,232 @@
+"""MCP + REST server for mnemonics.
+
+Endpoints:
+  GET  /health
+  POST /ingest   {"texts": [...], "ns": "default", "meta": [...]}
+  POST /retrieve {"query": "...", "ns": "default", "top_k": 5, "verify": true}
+  GET  /namespaces
+  GET  /count?ns=default
+  DELETE /memory/<id>
+
+MCP tools (JSON-RPC over stdio):
+  mnemonics_ingest   — store memories
+  mnemonics_retrieve — search + verify
+  mnemonics_forget   — delete a memory by id
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Any
+from pathlib import Path
+
+from mnemonics.store import Store
+from mnemonics.ingest import ingest as _ingest
+from mnemonics.retrieve import retrieve as _retrieve
+
+MNEMONICS_PORT = int(os.environ.get("MNEMONICS_PORT", "7810"))
+MNEMONICS_PATH = os.environ.get("MNEMONICS_PATH", "~/.mnemonics")
+
+_store: Store | None = None
+
+
+def _get_store() -> Store:
+    global _store
+    if _store is None:
+        _store = Store(MNEMONICS_PATH)
+    return _store
+
+
+class _Handler(BaseHTTPRequestHandler):
+    def log_message(self, format: str, *args: Any) -> None:
+        pass
+
+    def _body(self) -> dict:
+        length = int(self.headers.get("Content-Length", 0))
+        if length == 0:
+            return {}
+        return json.loads(self.rfile.read(length))
+
+    def _json(self, code: int, data: Any) -> None:
+        body = json.dumps(data).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self) -> None:
+        path = self.path.split("?")[0]
+        if path == "/health":
+            self._json(200, {"status": "ok", "version": "0.1.0"})
+        elif path == "/namespaces":
+            self._json(200, {"namespaces": _get_store().list_namespaces()})
+        elif path == "/count":
+            ns = (self.path.split("ns=")[-1] if "ns=" in self.path else "default")
+            self._json(200, {"ns": ns, "count": _get_store().count(ns)})
+        else:
+            self._json(404, {"error": "not found"})
+
+    def do_POST(self) -> None:
+        try:
+            body = self._body()
+        except Exception:
+            self._json(400, {"error": "invalid JSON"})
+            return
+
+        if self.path == "/ingest":
+            texts = body.get("texts", [])
+            if not texts:
+                self._json(400, {"error": "texts must not be empty"})
+                return
+            n = _ingest(
+                texts=texts,
+                store=_get_store(),
+                ns=body.get("ns", "default"),
+                meta=body.get("meta"),
+            )
+            self._json(200, {"ingested": n})
+
+        elif self.path == "/retrieve":
+            query = body.get("query", "").strip()
+            if not query:
+                self._json(400, {"error": "query must not be empty"})
+                return
+            result = _retrieve(
+                query=query,
+                store=_get_store(),
+                ns=body.get("ns", "default"),
+                top_k=int(body.get("top_k", 5)),
+                verify=bool(body.get("verify", True)),
+            )
+            self._json(200, result)
+
+        else:
+            self._json(404, {"error": "not found"})
+
+    def do_DELETE(self) -> None:
+        if self.path.startswith("/memory/"):
+            try:
+                mid = int(self.path.split("/memory/")[1])
+                ok = _get_store().delete(mid)
+                self._json(200, {"deleted": ok})
+            except ValueError:
+                self._json(400, {"error": "invalid id"})
+        else:
+            self._json(404, {"error": "not found"})
+
+
+# ── MCP stdio mode ───────────────────────────────────────────────────────────
+
+def _mcp_loop() -> None:
+    """JSON-RPC over stdin/stdout for MCP clients (Claude Code, Cursor, Metis)."""
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except Exception:
+            continue
+
+        rid = req.get("id")
+        method = req.get("method", "")
+        params = req.get("params", {})
+
+        def ok(result: Any) -> None:
+            print(json.dumps({"jsonrpc": "2.0", "id": rid, "result": result}), flush=True)
+
+        def err(msg: str, code: int = -32600) -> None:
+            print(json.dumps({"jsonrpc": "2.0", "id": rid, "error": {"code": code, "message": msg}}), flush=True)
+
+        if method == "initialize":
+            ok({
+                "protocolVersion": "2024-11-05",
+                "serverInfo": {"name": "mnemonics", "version": "0.1.0"},
+                "capabilities": {"tools": {}},
+            })
+
+        elif method == "tools/list":
+            ok({"tools": [
+                {
+                    "name": "mnemonics_ingest",
+                    "description": "Store text memories into mnemonics. Chunks, embeds and persists.",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "texts": {"type": "array", "items": {"type": "string"}},
+                            "ns": {"type": "string", "description": "Namespace (default: 'default')"},
+                        },
+                        "required": ["texts"],
+                    },
+                },
+                {
+                    "name": "mnemonics_retrieve",
+                    "description": "Search memories for a query. Returns top results with hallucination verification.",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string"},
+                            "ns": {"type": "string"},
+                            "top_k": {"type": "integer"},
+                            "verify": {"type": "boolean", "description": "Run halluguard verification (default true)"},
+                        },
+                        "required": ["query"],
+                    },
+                },
+                {
+                    "name": "mnemonics_forget",
+                    "description": "Delete a memory by id.",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {"id": {"type": "integer"}},
+                        "required": ["id"],
+                    },
+                },
+            ]})
+
+        elif method == "tools/call":
+            name = params.get("name")
+            args = params.get("arguments", {})
+
+            if name == "mnemonics_ingest":
+                texts = args.get("texts", [])
+                n = _ingest(texts=texts, store=_get_store(), ns=args.get("ns", "default"))
+                ok({"content": [{"type": "text", "text": f"Stored {n} chunks."}]})
+
+            elif name == "mnemonics_retrieve":
+                result = _retrieve(
+                    query=args["query"],
+                    store=_get_store(),
+                    ns=args.get("ns", "default"),
+                    top_k=int(args.get("top_k", 5)),
+                    verify=bool(args.get("verify", True)),
+                )
+                lines = [f"trust_score: {result['trust_score']}  flagged: {result['flagged_count']}"]
+                for r in result["results"]:
+                    flag = " ⚠ FLAGGED" if r.get("flagged") else ""
+                    lines.append(f"[{r['score']:.3f}]{flag} {r['text'][:200]}")
+                ok({"content": [{"type": "text", "text": "\n".join(lines)}]})
+
+            elif name == "mnemonics_forget":
+                deleted = _get_store().delete(int(args["id"]))
+                ok({"content": [{"type": "text", "text": f"Deleted: {deleted}"}]})
+
+            else:
+                err(f"unknown tool: {name}")
+        else:
+            err(f"unknown method: {method}")
+
+
+def serve(port: int = MNEMONICS_PORT, mcp: bool = False) -> None:
+    if mcp:
+        _mcp_loop()
+        return
+    print(f"[mnemonics] listening on :{port}", flush=True)
+    server = HTTPServer(("127.0.0.1", port), _Handler)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        sys.exit(0)

mnemonics/store.py

@@ -0,0 +1,110 @@
+"""Persistent storage: SQLite (metadata) + hnswlib (vectors)."""
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from pathlib import Path
+from typing import Any
+
+import hnswlib
+import numpy as np
+
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS memories (
+    id       INTEGER PRIMARY KEY AUTOINCREMENT,
+    ns       TEXT NOT NULL DEFAULT 'default',
+    text     TEXT NOT NULL,
+    meta     TEXT NOT NULL DEFAULT '{}',
+    created  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_ns ON memories(ns);
+"""
+
+DIM = 384  # all-MiniLM-L6-v2 output dim
+
+
+class Store:
+    """Thread-safe memory store backed by SQLite + hnswlib."""
+
+    def __init__(self, path: str | Path = "~/.mnemonics"):
+        self.root = Path(path).expanduser()
+        self.root.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+        self._db = sqlite3.connect(str(self.root / "memories.db"), check_same_thread=False)
+        self._db.executescript(_SCHEMA)
+        self._db.commit()
+        self._index: dict[str, hnswlib.Index] = {}
+
+    def _index_for(self, ns: str) -> hnswlib.Index:
+        if ns not in self._index:
+            idx_path = self.root / f"index_{ns}.bin"
+            idx = hnswlib.Index(space="cosine", dim=DIM)
+            if idx_path.exists():
+                idx.load_index(str(idx_path))
+                idx.set_ef(64)
+            else:
+                idx.init_index(max_elements=100_000, ef_construction=200, M=16)
+                idx.set_ef(64)
+            self._index[ns] = idx
+        return self._index[ns]
+
+    def add(self, texts: list[str], vectors: np.ndarray, ns: str = "default", meta: list[dict] | None = None) -> list[int]:
+        if meta is None:
+            meta = [{} for _ in texts]
+        with self._lock:
+            ids = []
+            for text, m in zip(texts, meta):
+                cur = self._db.execute(
+                    "INSERT INTO memories (ns, text, meta) VALUES (?, ?, ?)",
+                    (ns, text, json.dumps(m)),
+                )
+                ids.append(cur.lastrowid)
+            self._db.commit()
+            idx = self._index_for(ns)
+            idx.add_items(vectors, ids)
+            idx.save_index(str(self.root / f"index_{ns}.bin"))
+        return ids
+
+    def search(self, vector: np.ndarray, ns: str = "default", top_k: int = 5) -> list[dict[str, Any]]:
+        with self._lock:
+            idx = self._index_for(ns)
+            n = min(top_k, idx.get_current_count())
+            if n == 0:
+                return []
+            labels, distances = idx.knn_query(vector, k=n)
+            row_ids = [int(x) for x in labels[0]]
+            placeholders = ",".join("?" * len(row_ids))
+            rows = self._db.execute(
+                f"SELECT id, text, meta, created FROM memories WHERE id IN ({placeholders})",
+                row_ids,
+            ).fetchall()
+            by_id = {r[0]: r for r in rows}
+            results = []
+            for rid, dist in zip(labels[0], distances[0]):
+                row = by_id.get(int(rid))
+                if row is None:
+                    continue
+                results.append({
+                    "id": row[0],
+                    "text": row[1],
+                    "meta": json.loads(row[2]),
+                    "created": row[3],
+                    "score": float(1 - dist),
+                })
+        return results
+
+    def list_namespaces(self) -> list[str]:
+        rows = self._db.execute("SELECT DISTINCT ns FROM memories ORDER BY ns").fetchall()
+        return [r[0] for r in rows]
+
+    def count(self, ns: str = "default") -> int:
+        row = self._db.execute("SELECT COUNT(*) FROM memories WHERE ns=?", (ns,)).fetchone()
+        return row[0] if row else 0
+
+    def delete(self, memory_id: int) -> bool:
+        with self._lock:
+            cur = self._db.execute("DELETE FROM memories WHERE id=?", (memory_id,))
+            self._db.commit()
+        return cur.rowcount > 0

mnemonics-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: mnemonics
+Version: 0.1.0
+Summary: Verified AI memory — retrieval that doesn't hallucinate.
+Author: atakan
+License-Expression: MIT
+Keywords: llm,memory,retrieval,rag,hallucination,mcp,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: hnswlib>=0.8
+Requires-Dist: sentence-transformers>=3.0
+Requires-Dist: requests>=2.28
+Provides-Extra: verify
+Requires-Dist: halluguard>=0.3; extra == "verify"
+Provides-Extra: server
+Requires-Dist: halluguard>=0.3; extra == "server"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+
+# Mnemonics
+
+**Your memory doesn't hallucinate.**
+
+Mnemonics is a local-first AI memory layer that stores, retrieves, and *verifies* what it returns. Built on sentence embeddings + HNSW vector search, with optional [halluguard](https://github.com/nakata-app/halluguard) verification to flag results that drift from the indexed corpus.
+
+## Why
+
+Every RAG pipeline has the same silent failure mode: the retriever returns plausible-looking chunks, the LLM fills in the gaps, and nobody notices the fabrication until it matters. Mnemonics surfaces that problem at retrieval time, not after.
+
+## Install
+
+```bash
+pip install mnemonics
+# with verification support:
+pip install "mnemonics[verify]"
+```
+
+## Quick start
+
+```bash
+# Store something
+mnemonics ingest "The Eiffel Tower is 330 meters tall and located in Paris."
+
+# Retrieve with hallucination check
+mnemonics retrieve "how tall is the Eiffel Tower"
+# trust_score: 1.0  flagged: 0
+#   [0.912] The Eiffel Tower is 330 meters tall and located in Paris.
+```
+
+## Python API
+
+```python
+from mnemonics.store import Store
+from mnemonics.ingest import ingest
+from mnemonics.retrieve import retrieve
+
+store = Store("~/.mnemonics")
+
+ingest(["Paris is the capital of France.", "Rome is the capital of Italy."], store)
+
+result = retrieve("what is the capital of France", store, top_k=3, verify=True)
+for r in result["results"]:
+    flag = " FLAGGED" if r["flagged"] else ""
+    print(f"[{r['score']:.3f}]{flag} {r['text']}")
+
+print(f"trust_score: {result['trust_score']}")
+```
+
+## REST server
+
+```bash
+mnemonics serve --port 7810
+```
+
+| Method | Path | Body |
+|--------|------|------|
+| POST | `/ingest` | `{"texts": [...], "ns": "default"}` |
+| POST | `/retrieve` | `{"query": "...", "top_k": 5, "verify": true}` |
+| GET | `/health` | |
+| GET | `/namespaces` | |
+| GET | `/count?ns=default` | |
+| DELETE | `/memory/<id>` | |
+
+## MCP (Claude Code / Cursor / Metis)
+
+```bash
+mnemonics mcp
+```
+
+Add to your MCP config:
+
+```json
+{
+  "mcpServers": {
+    "mnemonics": {
+      "command": "mnemonics",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+Tools exposed: `mnemonics_ingest`, `mnemonics_retrieve`, `mnemonics_forget`
+
+## Namespaces
+
+Isolate memories by project, user, or any key:
+
+```bash
+mnemonics ingest "project notes..." --ns work
+mnemonics retrieve "deadlines" --ns work
+```
+
+## Architecture
+
+```
+texts -> chunk (200w / 40w overlap) -> embed (all-MiniLM-L6-v2)
+      -> hnswlib cosine index (per namespace)
+      -> SQLite metadata store
+
+retrieve -> embed query -> knn search -> halluguard verify -> ranked results
+```
+
+Storage layout under `~/.mnemonics`:
+
+```
+memories.db        SQLite (text, meta, timestamps)
+index_default.bin  hnswlib index for "default" namespace
+index_<ns>.bin     one index per namespace
+```
+
+## Verification
+
+When `verify=True`, retrieved chunks are sent to a local halluguard daemon (port 7801) which cross-checks each result against the full retrieved corpus. Results that diverge get flagged and the aggregate `trust_score` drops.
+
+```bash
+pip install "mnemonics[verify]"
+halluguard serve &
+mnemonics retrieve "your query"  # auto-verifies
+```
+
+Verification is best-effort: if the daemon is not running, retrieval proceeds normally with `trust_score: 1.0`.
+
+## License
+
+MIT

mnemonics-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+mnemonics/__init__.py,sha256=HNcDp5WPgCIcE_1MOaBZO3dWD46iF5gx1FFY8ityeLw,251
+mnemonics/cli.py,sha256=pLy313ls2RazYqhyZsjv4zgEm-GeT6J_BDHKtGnmVAI,2498
+mnemonics/ingest.py,sha256=F7cUWhh4K7LQ8iIleyjS1F484ptmyo7M0scSw9NF4vA,1741
+mnemonics/retrieve.py,sha256=fPdTvNCXC8Jnurlkt7XWgnoEcMrhc5GKlmhirfGKODA,2066
+mnemonics/server.py,sha256=wppzpeRW55Qxc9tIfZxLqcp7i9xHRKjnhHMt1S6hqR4,8390
+mnemonics/store.py,sha256=rD8V4WjKPRjpD69t2-woE9pXUKfcyuN0Rsd5vWkFhpo,3969
+mnemonics-0.1.0.dist-info/METADATA,sha256=nNbx_8bbRj8rmjFlHkhLP08uWCx29sTp3EVrD1Bbgsw,4113
+mnemonics-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mnemonics-0.1.0.dist-info/entry_points.txt,sha256=j0fjDfTRZ5QwkDi56gGycyPP40zBJdTt-ZM5U7kPpWk,49
+mnemonics-0.1.0.dist-info/top_level.txt,sha256=XC8R48GH1xNWd33VtcACI5p30usZwKtm7aUGll0rFak,10
+mnemonics-0.1.0.dist-info/RECORD,,

mnemonics-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mnemonics-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mnemonics = mnemonics.cli:main

mnemonics-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mnemonics