folio-cli 0.3.0__py3-none-any.whl

folio/retrieve.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .store import get_collection, load_bm25
+
+
+@dataclass
+class Hit:
+    chunk_id: str
+    text: str
+    score: float
+    source_id: str
+    rel_path: str
+    heading_path: str
+    dense_rank: int | None = None
+    bm25_rank: int | None = None
+
+
+def rrf_fuse(
+    ranked_lists: list[list[str]],
+    *,
+    k: int = 60,
+) -> dict[str, float]:
+    """Reciprocal Rank Fusion — merges rankings without score normalisation."""
+    scores: dict[str, float] = {}
+    for ranked in ranked_lists:
+        for rank, doc_id in enumerate(ranked, start=1):
+            scores[doc_id] = scores.get(doc_id, 0.0) + 1.0 / (k + rank)
+    return scores
+
+
+def _dense_search(cfg: dict[str, Any], query: str, k: int) -> list[tuple[str, str, dict, float]]:
+    collection = get_collection(cfg)
+    result = collection.query(
+        query_texts=[query],
+        n_results=min(k, max(collection.count(), 1)),
+        include=["documents", "metadatas", "distances"],
+    )
+    ids = result["ids"][0] if result["ids"] else []
+    docs = result["documents"][0] if result["documents"] else []
+    metas = result["metadatas"][0] if result["metadatas"] else []
+    dists = result["distances"][0] if result["distances"] else []
+    out: list[tuple[str, str, dict, float]] = []
+    for i, doc_id in enumerate(ids):
+        # cosine distance → similarity-ish for ranking display
+        sim = 1.0 - float(dists[i]) if i < len(dists) else 0.0
+        out.append((doc_id, docs[i], metas[i] or {}, sim))
+    return out
+
+
+def _bm25_search(cfg: dict[str, Any], query: str, k: int) -> list[tuple[str, str, dict, float]]:
+    payload = load_bm25(cfg["paths"]["bm25_path"])
+    bm25 = payload["bm25"]
+    ids: list[str] = payload["ids"]
+    texts: list[str] = payload["texts"]
+    metas: list[dict] = payload["metadatas"]
+    scores = bm25.get_scores(query.lower().split())
+    ranked = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:k]
+    return [(ids[i], texts[i], metas[i], float(scores[i])) for i in ranked if scores[i] > 0]
+
+
+def retrieve(
+    cfg: dict[str, Any],
+    query: str,
+    *,
+    final_k: int | None = None,
+    use_rerank: bool = False,
+    source_filter: str | None = None,
+) -> list[Hit]:
+    """
+    Hybrid path from senior revision (Bench):
+      query → BM25 + dense → RRF → CRAG widen → optional cross-encoder → top-k
+    """
+    rcfg = cfg["retrieval"]
+    dense_k = int(rcfg["dense_k"])
+    bm25_k = int(rcfg["bm25_k"])
+    final_k = final_k or int(rcfg["final_k"])
+    rrf_k = int(rcfg["rrf_k"])
+
+    dense_hits = _dense_search(cfg, query, dense_k)
+    bm25_hits = _bm25_search(cfg, query, bm25_k)
+
+    dense_ids = [h[0] for h in dense_hits]
+    bm25_ids = [h[0] for h in bm25_hits]
+    fused = rrf_fuse([dense_ids, bm25_ids], k=rrf_k)
+
+    # CRAG-style widen when best fusion score is weak
+    best = max(fused.values()) if fused else 0.0
+    if best < float(rcfg["crag_min_best_score"]):
+        widen = int(rcfg["crag_widen_factor"])
+        dense_hits = _dense_search(cfg, query, dense_k * widen)
+        bm25_hits = _bm25_search(cfg, query, bm25_k * widen)
+        fused = rrf_fuse([[h[0] for h in dense_hits], [h[0] for h in bm25_hits]], k=rrf_k)
+
+    by_id: dict[str, tuple[str, dict]] = {}
+    dense_rank = {h[0]: i + 1 for i, h in enumerate(dense_hits)}
+    bm25_rank = {h[0]: i + 1 for i, h in enumerate(bm25_hits)}
+    for doc_id, text, meta, _ in dense_hits + bm25_hits:
+        by_id[doc_id] = (text, meta)
+
+    ordered = sorted(fused.items(), key=lambda x: x[1], reverse=True)
+    hits: list[Hit] = []
+    for doc_id, score in ordered:
+        if doc_id not in by_id:
+            continue
+        text, meta = by_id[doc_id]
+        sid = str(meta.get("source_id", ""))
+        if source_filter and sid != source_filter:
+            continue
+        hits.append(
+            Hit(
+                chunk_id=doc_id,
+                text=text,
+                score=score,
+                source_id=sid,
+                rel_path=str(meta.get("rel_path", "")),
+                heading_path=str(meta.get("heading_path", "")),
+                dense_rank=dense_rank.get(doc_id),
+                bm25_rank=bm25_rank.get(doc_id),
+            )
+        )
+
+    if use_rerank and hits:
+        hits = _cross_encoder_rerank(cfg, query, hits, final_k * 3)[:final_k]
+    else:
+        hits = hits[:final_k]
+
+    floor = float(rcfg.get("confidence_floor", 0.0))
+    return [h for h in hits if h.score >= floor]
+
+
+def _cross_encoder_rerank(
+    cfg: dict[str, Any], query: str, hits: list[Hit], pool: int
+) -> list[Hit]:
+    try:
+        from sentence_transformers import CrossEncoder
+    except ImportError as e:
+        raise RuntimeError(
+            "Rerank requires optional deps: pip install 'folio[rerank]'"
+        ) from e
+
+    model_name = cfg["retrieval"]["reranker_model"]
+    model = CrossEncoder(model_name)
+    pool_hits = hits[:pool]
+    pairs = [(query, h.text) for h in pool_hits]
+    scores = model.predict(pairs)
+    rescored = []
+    for h, s in zip(pool_hits, scores):
+        rescored.append(
+            Hit(
+                chunk_id=h.chunk_id,
+                text=h.text,
+                score=float(s),
+                source_id=h.source_id,
+                rel_path=h.rel_path,
+                heading_path=h.heading_path,
+                dense_rank=h.dense_rank,
+                bm25_rank=h.bm25_rank,
+            )
+        )
+    rescored.sort(key=lambda x: x.score, reverse=True)
+    return rescored
+
+
+def format_context(hits: list[Hit], *, max_chars: int = 12000) -> str:
+    parts: list[str] = []
+    used = 0
+    for i, h in enumerate(hits, start=1):
+        header = (
+            f"[{i}] source={h.source_id} file={h.rel_path}\n"
+            f"heading={h.heading_path} score={h.score:.4f}\n"
+        )
+        body = h.text
+        block = f"{header}{body}\n"
+        if used + len(block) > max_chars:
+            # Always emit at least one (possibly truncated) citation.
+            if not parts:
+                room = max(max_chars - used - len(header) - 1, 0)
+                parts.append(f"{header}{body[:room]}\n")
+            break
+        parts.append(block)
+        used += len(block)
+    return "\n---\n".join(parts)

folio/store.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import os
+import pickle
+import shutil
+from pathlib import Path
+from typing import Any
+
+import chromadb
+from chromadb.api.models.Collection import Collection
+from chromadb.utils.embedding_functions import DefaultEmbeddingFunction
+from rank_bm25 import BM25Okapi
+
+from .chunk import Chunk
+
+
+def _ensure_local_chroma_cache(model_cache_dir: Path | None = None) -> Path:
+    """Keep ONNX model cache under the folio index home (sandbox-friendly).
+
+    Chroma binds ``ONNXMiniLM_L6_V2.DOWNLOAD_PATH`` at import time from Path.home(),
+    so we rewrite that class attribute to a folio-local directory.
+    """
+    cache = (model_cache_dir or Path.home() / ".folio" / "model-cache").resolve()
+    cache.mkdir(parents=True, exist_ok=True)
+    # Do NOT rewrite $HOME — that breaks Path.home() for the whole process.
+    os.environ["CHROMA_CACHE_DIR"] = str(cache)
+    os.environ["XDG_CACHE_HOME"] = str(cache)
+
+    from chromadb.utils.embedding_functions.onnx_mini_lm_l6_v2 import ONNXMiniLM_L6_V2
+
+    download = cache / "onnx_models" / ONNXMiniLM_L6_V2.MODEL_NAME
+    download.mkdir(parents=True, exist_ok=True)
+    ONNXMiniLM_L6_V2.DOWNLOAD_PATH = download
+
+    real_home = Path.home()
+    for candidate in (
+        real_home / ".cache/chroma/onnx_models" / ONNXMiniLM_L6_V2.MODEL_NAME,
+        real_home / ".folio" / "model-cache" / "onnx_models" / ONNXMiniLM_L6_V2.MODEL_NAME,
+        real_home
+        / ".folio"
+        / "model-cache"
+        / "home"
+        / ".cache"
+        / "chroma"
+        / "onnx_models"
+        / ONNXMiniLM_L6_V2.MODEL_NAME,
+        Path(__file__).resolve().parents[2] / "data/model-cache/onnx_models" / ONNXMiniLM_L6_V2.MODEL_NAME,
+    ):
+        if (candidate / "onnx" / "model.onnx").exists() and not (
+            download / "onnx" / "model.onnx"
+        ).exists():
+            shutil.copytree(candidate, download, dirs_exist_ok=True)
+            break
+    return cache
+
+
+def get_embedding_fn(model_cache_dir: Path | None = None) -> DefaultEmbeddingFunction:
+    _ensure_local_chroma_cache(model_cache_dir)
+    return DefaultEmbeddingFunction()
+
+
+def get_collection(cfg: dict[str, Any]) -> Collection:
+    cache = Path(cfg["paths"]["model_cache_dir"])
+    _ensure_local_chroma_cache(cache)
+    client = chromadb.PersistentClient(path=str(cfg["paths"]["chroma_dir"]))
+    emb = get_embedding_fn(cache)
+    return client.get_or_create_collection(
+        name=cfg["collection"]["name"],
+        embedding_function=emb,
+        metadata={"hnsw:space": "cosine"},
+    )
+
+
+def reset_collection(cfg: dict[str, Any]) -> Collection:
+    cache = Path(cfg["paths"]["model_cache_dir"])
+    _ensure_local_chroma_cache(cache)
+    client = chromadb.PersistentClient(path=str(cfg["paths"]["chroma_dir"]))
+    name = cfg["collection"]["name"]
+    try:
+        client.delete_collection(name)
+    except Exception:
+        pass
+    return get_collection(cfg)
+
+
+def upsert_chunks(collection: Collection, chunks: list[Chunk], batch_size: int = 64) -> int:
+    if not chunks:
+        return 0
+    from tqdm import tqdm
+
+    for i in tqdm(range(0, len(chunks), batch_size), desc="embedding+upsert"):
+        batch = chunks[i : i + batch_size]
+        collection.upsert(
+            ids=[c.chunk_id for c in batch],
+            documents=[c.text for c in batch],
+            metadatas=[c.to_metadata() for c in batch],
+        )
+    return len(chunks)
+
+
+def build_bm25(chunks: list[Chunk]) -> tuple[BM25Okapi, list[str], list[Chunk]]:
+    tokenized = [c.text.lower().split() for c in chunks]
+    return BM25Okapi(tokenized), [c.chunk_id for c in chunks], chunks
+
+
+def save_bm25(path: Path, bm25: BM25Okapi, ids: list[str], chunks: list[Chunk]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "bm25": bm25,
+        "ids": ids,
+        "texts": [c.text for c in chunks],
+        "metadatas": [c.to_metadata() for c in chunks],
+    }
+    with path.open("wb") as f:
+        pickle.dump(payload, f)
+
+
+def load_bm25(path: Path) -> dict[str, Any]:
+    with path.open("rb") as f:
+        return pickle.load(f)

folio/sync.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def _run(cmd: list[str], cwd: Path | None = None) -> None:
+    subprocess.run(cmd, cwd=cwd, check=True)
+
+
+def _clone_url(repo: str) -> str:
+    """Normalize local paths to file:// so sparse/depth clones behave."""
+    path = Path(repo)
+    if path.exists():
+        return path.resolve().as_uri()
+    return repo
+
+
+def _is_full_tree(sparse: str) -> bool:
+    return sparse.strip() in {".", "", "/"}
+
+
+def _content_root(dest: Path, sparse: str) -> Path:
+    if _is_full_tree(sparse):
+        return dest
+    return dest / sparse
+
+
+def sync_sources(cfg: dict[str, Any], force: bool = False) -> list[Path]:
+    """Sparse-clone / pull each configured GitHub path into data/sources/<id>/."""
+    sources_dir: Path = cfg["paths"]["sources_dir"]
+    sources_dir.mkdir(parents=True, exist_ok=True)
+    synced: list[Path] = []
+
+    for src in cfg["sources"]:
+        dest = sources_dir / src["id"]
+        sparse = src["sparse_path"]
+        branch = src.get("branch", "main")
+        repo = _clone_url(src["repo"])
+        full = _is_full_tree(sparse)
+
+        if dest.exists() and force:
+            shutil.rmtree(dest)
+
+        if dest.exists() and (dest / ".git").exists():
+            _run(["git", "fetch", "--depth", "1", "origin", branch], cwd=dest)
+            if full:
+                # materialize whole tree (sparse "." only keeps cone root)
+                _run(["git", "sparse-checkout", "disable"], cwd=dest)
+                _run(["git", "checkout", f"origin/{branch}", "--", "."], cwd=dest)
+            else:
+                _run(["git", "checkout", f"origin/{branch}", "--", sparse], cwd=dest)
+                _run(["git", "sparse-checkout", "set", sparse], cwd=dest)
+        else:
+            if dest.exists():
+                shutil.rmtree(dest)
+            if full:
+                _run(
+                    [
+                        "git",
+                        "clone",
+                        "--depth",
+                        "1",
+                        "--branch",
+                        branch,
+                        repo,
+                        str(dest),
+                    ]
+                )
+            else:
+                dest.mkdir(parents=True, exist_ok=True)
+                _run(
+                    [
+                        "git",
+                        "clone",
+                        "--depth",
+                        "1",
+                        "--filter=blob:none",
+                        "--sparse",
+                        "--branch",
+                        branch,
+                        repo,
+                        str(dest),
+                    ]
+                )
+                _run(["git", "sparse-checkout", "set", sparse], cwd=dest)
+
+        content_root = _content_root(dest, sparse)
+        if not content_root.exists():
+            raise FileNotFoundError(f"Expected sparse path missing: {content_root}")
+        synced.append(content_root)
+        print(f"[sync] {src['id']} → {content_root}")
+
+    return synced
+
+
+def iter_markdown(cfg: dict[str, Any]) -> list[tuple[str, Path]]:
+    """Return (source_id, absolute md path) for every markdown file under synced roots."""
+    sources_dir: Path = cfg["paths"]["sources_dir"]
+    out: list[tuple[str, Path]] = []
+    for src in cfg["sources"]:
+        root = _content_root(sources_dir / src["id"], src["sparse_path"])
+        if not root.exists():
+            continue
+        for path in sorted(root.rglob("*.md")):
+            if path.is_file() and ".git" not in path.parts:
+                out.append((src["id"], path))
+    return out

folio_cli-0.3.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: folio-cli
+Version: 0.3.0
+Summary: Local hybrid RAG over curated AI / MLOps / infra curricula — graphify-style CLI for any assistant
+Author: Iman Sharei
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Iman-Sharei/folio
+Project-URL: Repository, https://github.com/Iman-Sharei/folio
+Project-URL: Issues, https://github.com/Iman-Sharei/folio/issues
+Project-URL: Changelog, https://github.com/Iman-Sharei/folio/releases
+Keywords: rag,mlops,ai-engineering,chromadb,cli,uv
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: chromadb<1.1,>=0.5.23
+Requires-Dist: rank-bm25>=0.2.2
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: tqdm>=4.66.0
+Requires-Dist: numpy<3,>=1.26.0
+Provides-Extra: rerank
+Requires-Dist: sentence-transformers<6,>=3.3.0; extra == "rerank"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# folio
+
+Local hybrid RAG over curated **AI engineering / MLOps / AI infra** markdown curricula
+(graphify-style CLI). Assistants query a **shared machine index** instead of stuffing
+GitHub repos into chat — lower token use, grounded citations.
+
+| Source | Path |
+|--------|------|
+| [02-senior-ai-engineer-study-path](https://github.com/RavSinghChandan/02-senior-ai-engineer-study-path) | `revision-1/` |
+| [ai-infra-senior-engineer-learning](https://github.com/ai-infra-curriculum/ai-infra-senior-engineer-learning) | `lessons/` |
+| [agentic-ai-developer-learning](https://github.com/ai-engineering-curriculum/agentic-ai-developer-learning) | `lessons/` |
+| [agentic-ai-engineer-learning](https://github.com/ai-engineering-curriculum/agentic-ai-engineer-learning) | `lessons/` |
+| [senior-agentic-ai-engineer-learning](https://github.com/ai-engineering-curriculum/senior-agentic-ai-engineer-learning) | `lessons/` |
+| [applied-ai-engineer-learning](https://github.com/ai-engineering-curriculum/applied-ai-engineer-learning) | `lessons/` |
+| [ai-eval-engineer-learning](https://github.com/ai-engineering-curriculum/ai-eval-engineer-learning) | `lessons/` |
+| [agentic-systems-architect-learning](https://github.com/ai-engineering-curriculum/agentic-systems-architect-learning) | `lessons/` |
+| [mlops-zoomcamp](https://github.com/DataTalksClub/mlops-zoomcamp) | repo MD modules |
+
+## Install (once on this machine)
+
+PyPI distribution name is **`folio-cli`** (plain `folio` is taken). The CLI command is still **`folio`**.
+
+```bash
+uv tool install folio-cli
+folio --help
+```
+
+From a checkout (editable / unreleased):
+
+```bash
+cd ~/Desktop/folio
+uv tool install --editable .
+# or: uv sync && uv run folio status
+```
+
+Git install without waiting for PyPI:
+
+```bash
+uv tool install git+https://github.com/Iman-Sharei/folio
+```
+
+## Get the knowledge index
+
+Index lives in **`~/.folio/`** (override with `FOLIO_HOME`). Not inside product repos.
+
+```bash
+folio bootstrap                # preferred: prebuilt pack from Release
+# or:
+folio build                    # sync curated sources + embed (slower)
+folio status
+```
+
+Refresh when the maintainer publishes new curricula:
+
+```bash
+folio update                   # download new Release pack (falls back to build)
+folio update --from-source     # force rebuild from git sources
+```
+
+Maintainer release flow:
+
+```bash
+folio build
+folio pack                     # → dist/folio-index-YYYY.MM.DD.tar.gz
+# upload tarball to GitHub Release; set release.index_url in config
+```
+
+## Use from any project (like graphify)
+
+```bash
+cd /path/to/your-project
+folio install --project --platform cursor
+folio query "hybrid RAG vs RAGless" --json
+```
+
+**Token rule:** assistants must **not** WebFetch/clone curriculum repos into chat.
+Only `folio query`.
+
+## Architecture
+
+```
+curated MD → chunk → ONNX MiniLM
+              ↓
+   ChromaDB + BM25  →  ~/.folio/
+              ↓
+query → dense + BM25 → RRF → CRAG → citations (~1–2k tokens, not the whole corpus)
+```
+
+## Commands
+
+```bash
+folio bootstrap [--url URL] [--archive FILE] [--force]
+folio build
+folio update [--from-source]
+folio pack [--dest PATH]
+folio sync
+folio query "<q>" [--json] [-k N] [--rerank]
+folio status
+folio install --project --platform cursor|claude|codex|agents
+folio uninstall --project [--purge]
+```
+
+## Tests
+
+```bash
+uv sync --extra dev
+uv run pytest -q                  # all
+uv run pytest -q -m "not integration"   # fast (no Chroma embed)
+uv run pytest -q -m integration         # sync + ingest + retrieve + pack
+```
+
+CI runs both layers on Python 3.11/3.12. Tag `vX.Y.Z` to:
+- upload the curricula index pack (`folio-index.tar.gz`) to the GitHub Release
+- publish the `folio-cli` wheel/sdist to PyPI (Trusted Publishing; see below)
+
+## Maintainer: publish `folio-cli` to PyPI
+
+One-time setup (API token **or** Trusted Publishing):
+
+```bash
+./scripts/publish-pypi-wizard.sh
+```
+
+After Trusted Publishing is configured, a version tag is enough:
+
+```bash
+git tag -a v0.3.0 -m v0.3.0
+git push origin v0.3.0
+```
+
+Manual local publish (token in env):
+
+```bash
+uv build
+UV_PUBLISH_TOKEN=pypi-... uv publish
+```
+
+## Maintainer: publish index for `folio bootstrap`
+
+```bash
+folio build
+folio pack                 # → dist/folio-index-YYYY.MM.DD.tar.gz
+# upload as GitHub Release asset, then set in config:
+# release.index_url: https://github.com/<you>/folio/releases/latest/download/folio-index.tar.gz
+```

folio_cli-0.3.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+folio/__init__.py,sha256=Q77p87qEG_CqU5xHsu6FYG9y56H_6jnxAzwv-N-JXrc,115
+folio/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+folio/chunk.py,sha256=0zNJSMkMVwJmJHKc_HGN5sF4N3Cvku175wiFZ36qNCM,4752
+folio/cli.py,sha256=XeYzVheI3CW5X3JlJ6udn95vt40YG8VCL1A2hYAgKlk,9789
+folio/config.py,sha256=1mcPxE8dQ73l-1MsFSX2dyKoT3OuadqalYhNECohv-g,3058
+folio/distribute.py,sha256=MRODICLDkJkqUyvV5DAN43TcMlYWrBT2JL22BA16r_0,5953
+folio/ingest.py,sha256=kFZVyd65WFVTdA8ErJYz6e1iKnwz4ZhHtnHxvFliSP8,2465
+folio/install.py,sha256=Dii5KAYlpMyzusBEkjKbUuu9xBKoka4BgYokNl-mTDI,10443
+folio/retrieve.py,sha256=hFZEUXZalyvOyFm1tcaHBgSwzMiziXDQJ7LpDjW5IBU,6273
+folio/store.py,sha256=_CFj56P_piuqKI6RjBdlAVYmVFF0SRNhw0VRJFpiY8Y,4085
+folio/sync.py,sha256=vbEJsF_D6tLggveyXqdezRKwfx9XrceNO1LivhOYMaQ,3673
+folio/assets/SKILL.md,sha256=iKp6s_Rj_xmIsCcotC4Ks0BJi5DId0UhOchZk1aB7Rc,3048
+folio/assets/__init__.py,sha256=8q20BIdzAx2q3dbubqUibZCBdLz8-YXgmf_DJzs9O9Q,56
+folio/assets/config.yaml,sha256=bvAHUds1o9NvbiSU2KFgIQDVJnioC2fLb6pV-yUTSpI,2366
+folio_cli-0.3.0.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+folio_cli-0.3.0.dist-info/METADATA,sha256=XEU6gpYx0HvOMd9K6fcVmf6GSq-CsW0a3BGZpJuvPvQ,5846
+folio_cli-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+folio_cli-0.3.0.dist-info/entry_points.txt,sha256=EmYULC3K327zuj7qeVnwcnV8Oj_fcd31B8Max_7Gfvo,41
+folio_cli-0.3.0.dist-info/top_level.txt,sha256=7_AGBjZLkQ_w5N3T3ujiEwtUghuLRfDJKS2n3kjj2gM,6
+folio_cli-0.3.0.dist-info/RECORD,,

folio_cli-0.3.0.dist-info/WHEEL

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

folio_cli-0.3.0.dist-info/entry_points.txt

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