confluence-knowledge 0.3.1__py3-none-any.whl

confluence_knowledge/server.py

@@ -0,0 +1,341 @@
+"""stdio MCP server — the only surface the Copilot agent can reach.
+
+Exposes narrow operations; no arbitrary HTTP/shell/file tools. Scope handles
+are opaque and bound to the site+account+root partition.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import threading
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from .auth import get_credential
+from .client import AccessError, ConfluenceClient, SecurityException, make_client
+from .crawl import Crawler
+from .index import Index
+from .retrieval import LocalEmbedder, LocalReranker, check_citations, retrieve
+from .settings import (
+    SetupError,
+    SiteProfile,
+    default_home,
+    extract_page_id,
+    resolve_workdir,
+    workspace_index_root,
+)
+
+mcp = FastMCP("confluence-knowledge")
+
+# in-process caches (per server lifetime)
+_scopes: dict[str, dict] = {}
+_evidence_sets: dict[str, list[dict]] = {}
+_indexes: dict[str, Index] = {}  # one connection per DB for the server lifetime
+_clients: dict[str, ConfluenceClient] = {}  # one HTTP pool per credential
+_EMBEDDER = None
+_RERANKER = None
+_model_lock = threading.Lock()
+_models_ready = threading.Event()
+_warm_lock = threading.Lock()
+_warm_started = False
+
+LOADING_NOTE = "loading local models — call this tool again"
+
+
+def _home() -> Path:
+    return default_home()
+
+
+def _workdir() -> Path:
+    return resolve_workdir()
+
+
+def _step_seconds() -> float:
+    """Upper bound for one tool call, kept well under IDE request timeouts."""
+    return float(os.environ.get("CONF_KNOWLEDGE_STEP_SECONDS", "10"))
+
+
+def _client_for(profile: SiteProfile):
+    c = _clients.get(profile.credential_ref)
+    if c is None:
+        token = get_credential(_workdir(), profile.credential_ref)
+        if not token:
+            raise SetupError(
+                "no stored token — run `confluence-knowledge setup` to configure credentials")
+        c = _clients[profile.credential_ref] = make_client(profile, token)
+    return c
+
+
+def _index_for(scope_key: str) -> Index:
+    idx = _indexes.get(scope_key)
+    if idx is None:
+        idx = _indexes[scope_key] = Index(workspace_index_root(_workdir()) / f"{scope_key}.db")
+    return idx
+
+
+def _embedder():
+    global _EMBEDDER
+    with _model_lock:
+        if _EMBEDDER is None:
+            _EMBEDDER = LocalEmbedder(_home())
+    return _EMBEDDER
+
+
+def _reranker():
+    global _RERANKER
+    with _model_lock:
+        if _RERANKER is None:
+            _RERANKER = LocalReranker(_home())
+    return _RERANKER
+
+
+def _warm_models() -> None:
+    try:
+        _embedder()
+        _reranker()
+    except SetupError:
+        pass  # reported by the tool that needs the model
+    finally:
+        _models_ready.set()
+
+
+def _start_warmup() -> None:
+    """Load torch + both models off the request path; the first load can take
+    longer than an IDE's request timeout."""
+    global _warm_started
+    with _warm_lock:
+        if _warm_started:
+            return
+        _warm_started = True
+    threading.Thread(target=_warm_models, name="model-warmup", daemon=True).start()
+
+
+def _models_loaded(wait: float) -> bool:
+    _start_warmup()
+    return _models_ready.wait(wait)
+
+
+def _scope(scope_handle: str) -> dict:
+    s = _scopes.get(scope_handle)
+    if s is None:
+        # the IDE may restart the server (e.g. after a request timeout) and
+        # drop in-memory scopes; handles carry the root so they re-bind after
+        # the same identity check connect() performs
+        parts = scope_handle.split(":")
+        if len(parts) == 3 and parts[0] == "scope" and connect(parts[2])["scope_handle"] == scope_handle:
+            return _scopes[scope_handle]
+        raise SetupError("unknown scope — call connect first")
+    return s
+
+
+@mcp.tool()
+def status() -> dict:
+    """Report setup readiness — never returns secrets."""
+    home = _home()
+    try:
+        profile = SiteProfile.load(home)
+        cfg = {"env": profile.env, "site": profile.base_url}
+    except SetupError as e:
+        cfg = {"error": str(e)}
+    models = home / "models"
+    return {
+        "configured": "error" not in cfg,
+        "profile": cfg,
+        "embedding_model_ready": (models / "all-MiniLM-L6-v2").exists(),
+        "reranker_model_ready": (models / "ms-marco-MiniLM-L6-v2").exists(),
+        "models_loaded": _models_ready.is_set() and _EMBEDDER is not None,
+        "index_root": str(workspace_index_root(_workdir())),
+        "live_scopes": sorted(_scopes),
+    }
+
+
+@mcp.tool()
+def connect(root: str) -> dict:
+    """Validate credentials + root readability; bind a scope handle."""
+    profile = SiteProfile.load(_home())
+    root_id = extract_page_id(root)
+    _clients.pop(profile.credential_ref, None)  # re-read the token: setup may have rotated it
+    client = _client_for(profile)
+    who = client.get("wiki/rest/api/user/current" if profile.env == "cloud"
+                     else "rest/api/user/current").json()
+    principal = who.get("accountId") or who.get("userKey") or who.get("username") or "?"
+    scope_key = profile.scope_key(principal, root_id)
+    idx = _index_for(scope_key)
+    st = idx.stats()
+    handle = f"scope:{scope_key}:{root_id}"
+    _scopes[handle] = {"key": scope_key, "profile": profile, "root": root_id}
+    _start_warmup()
+    return {
+        "scope_handle": handle,
+        "root_page_id": root_id,
+        "principal": principal,
+        "cached": st["pages"] > 0,
+        "cached_pages": st["pages"],
+        "cached_as_of": st["as_of"],
+    }
+
+
+def _crawler(s: dict, embedder=None) -> Crawler:
+    return Crawler(_client_for(s["profile"]), _index_for(s["key"]), s["profile"].env,
+                   embedder=embedder, site_url=s["profile"].base_url)
+
+
+# background crawl workers — a crawl runs to completion server-side so a big
+# subtree doesn't need hundreds of tool calls (each one an IDE LLM turn and a
+# timeout surface, #81). crawl_step is then only a progress read.
+_workers: dict[str, threading.Thread] = {}
+_worker_errors: dict[str, str] = {}
+_workers_lock = threading.Lock()
+
+
+def _worker_loop(s: dict, job_id: str) -> None:
+    idx = _index_for(s["key"])
+    try:
+        # models may still be warming; the worker waits, not the tool call
+        _models_ready.wait()
+        c = _crawler(s, embedder=_embedder())
+        while True:
+            r = c.step(job_id, batch=None, budget_s=None)
+            if r["state"] != "running":
+                break
+    except Exception as e:  # noqa: BLE001 — surfaced via job state
+        err = f"{type(e).__name__}: {e}"
+        _worker_errors[f"{s['key']}:{job_id}"] = err
+        job = idx.job(job_id)
+        if job and job["state"] == "running":
+            idx.save_job(job_id, "error", job["queue"], job["errors"] + [err])
+
+
+def _ensure_worker(s: dict, job_id: str) -> None:
+    """Start the crawl worker if none is alive — also the resume path after
+    the server restarts mid-crawl (the queue is durable, the thread isn't)."""
+    key = f"{s['key']}:{job_id}"
+    with _workers_lock:
+        t = _workers.get(key)
+        if t is not None and t.is_alive():
+            return
+        _workers[key] = threading.Thread(
+            target=_worker_loop, args=(s, job_id),
+            name=f"crawl-{job_id}", daemon=True)
+        _workers[key].start()
+
+
+@mcp.tool()
+def start_crawl(scope_handle: str, refresh: bool = False) -> dict:
+    """Begin crawling the root page and all descendants in a background
+    thread. The crawl runs to completion without further input — call
+    crawl_step only to read progress."""
+    s = _scope(scope_handle)
+    job_id = _crawler(s).start(s["root"])
+    _ensure_worker(s, job_id)
+    return {"job_id": job_id, "state": "running",
+            "note": "crawl runs in the background — call crawl_step to poll"}
+
+
+@mcp.tool()
+def crawl_step(scope_handle: str, job_id: str) -> dict:
+    """Read crawl progress instantly. A running job with no live worker (e.g.
+    the server restarted mid-crawl) is resumed automatically; the queue and
+    per-page checkpoints are durable."""
+    s = _scope(scope_handle)
+    idx = _index_for(s["key"])
+    job = idx.job(job_id)
+    if job is None:
+        raise AccessError(f"unknown job {job_id}")
+    if job["state"] == "running":
+        if not _models_ready.is_set():
+            _start_warmup()
+            note = LOADING_NOTE
+        else:
+            note = None
+        _ensure_worker(s, job_id)
+        p = idx.job_progress(job_id)
+        if note:
+            p["note"] = note
+        return p
+    p = idx.job_progress(job_id)
+    if p["state"] == "done":
+        p["note"] = "no further calls needed — the index is published"
+    return p
+
+
+def _coverage(idx: Index) -> str:
+    job = idx.latest_job()
+    if job is None or job["state"] == "abandoned":
+        return "unknown"
+    if job["state"] == "running":
+        return "refresh in progress — answering from the previous snapshot"
+    return "partial" if job["errors"] else "complete"
+
+
+@mcp.tool()
+def search(scope_handle: str, question: str) -> dict:
+    """Hybrid retrieve + local rerank; returns bounded, cited evidence."""
+    s = _scope(scope_handle)
+    idx = _index_for(s["key"])
+    st = idx.stats()
+    if st["pages"] == 0:
+        job = idx.latest_job()
+        if job and job["state"] == "running":
+            return {"evidence": [], "coverage": "crawling",
+                    "note": f"crawl {job['job_id']} still running — keep calling crawl_step "
+                            "until state is done, then search"}
+        return {"evidence": [], "coverage": "empty",
+                "note": "no pages indexed — run a crawl first"}
+    if not _models_loaded(_step_seconds()):
+        return {"evidence": [], "coverage": "loading", "note": LOADING_NOTE}
+    ev = retrieve(idx, question, _embedder(), _reranker())
+    set_id = f"ev:{len(_evidence_sets)}:{s['key'][:8]}"
+    _evidence_sets[set_id] = ev
+    return {
+        "evidence_set": set_id,
+        "coverage": _coverage(idx),
+        "as_of": st["as_of"],
+        "evidence": [
+            {"chunk_id": e["chunk_id"], "page_title": e["page_title"],
+             "page_url": e["page_url"], "heading": e["heading"],
+             "score": e.get("rerank_score"), "text": e["text"][:2000]}
+            for e in ev
+        ],
+    }
+
+
+@mcp.tool()
+def get_evidence(scope_handle: str, chunk_ids: list[str]) -> dict:
+    """Return full text of previously returned chunks — same scope only."""
+    s = _scope(scope_handle)
+    idx = _index_for(s["key"])
+    all_chunks = {c["chunk_id"]: c for c in idx.active_chunks()}
+    out = []
+    for cid in chunk_ids[:16]:
+        c = all_chunks.get(cid)
+        if c is None:
+            raise SecurityException(f"chunk {cid} not in this scope's index")
+        p = idx.active_pages().get(c["page_id"], {})
+        out.append({"chunk_id": cid, "text": c["text"],
+                    "page_title": p.get("title", ""), "page_url": p.get("url", "")})
+    return {"chunks": out}
+
+
+@mcp.tool()
+def verify_citations(scope_handle: str, evidence_set: str,
+                     mappings: list[dict]) -> dict:
+    _scope(scope_handle)
+    ev = _evidence_sets.get(evidence_set)
+    if ev is None or not evidence_set.endswith(_scopes[scope_handle]["key"][:8]):
+        raise SecurityException(
+            "unknown or cross-scope evidence set — run search again and cite its evidence_set")
+    return check_citations(ev, mappings)
+
+
+def main() -> None:
+    # httpx logs every request URL at INFO; keep the IDE's MCP log readable
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    _start_warmup()
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

confluence_knowledge/settings.py

@@ -0,0 +1,156 @@
+"""Filesystem layout and validated settings for confluence-knowledge.
+
+All mutable state lives under the workspace's .conf_knowledge_index/ directory
+(or CONF_KNOWLEDGE_HOME). Nothing is written outside declared paths.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import urlparse
+
+INDEX_DIR_NAME = ".conf_knowledge_index"
+AUTH_FILE_NAME = ".conf_auth.json"
+APP_NAME = "confluence-knowledge"
+
+
+class SetupError(RuntimeError):
+    """A problem the user can fix via setup instructions."""
+
+
+def default_home() -> Path:
+    env = os.environ.get("CONF_KNOWLEDGE_HOME")
+    if env:
+        return Path(env).expanduser().resolve()
+    return (Path.home() / ".confluence-knowledge").resolve()
+
+
+def resolve_workdir() -> Path:
+    """Folder for the index and the file-fallback credential, shared by the CLI
+    and the server. CONF_KNOWLEDGE_WORKDIR wins; otherwise a per-user folder,
+    never the process cwd (IDEs start servers from read-only install dirs)."""
+    env = os.environ.get("CONF_KNOWLEDGE_WORKDIR")
+    if env:
+        return Path(env).expanduser().resolve()
+    return default_home() / "work"
+
+
+def workspace_index_root(workdir: Path) -> Path:
+    return workdir / INDEX_DIR_NAME
+
+
+def _is_windows() -> bool:
+    return os.name == "nt"
+
+
+def reject_unsafe_path(path: Path) -> Path:
+    """Refuse symlinked/reparse destinations so secrets/indices can't leak."""
+    resolved = path.expanduser()
+    for part in [resolved, *resolved.parents]:
+        if part.exists() and part.is_symlink():
+            raise SetupError(f"refusing to write through symlink: {part}")
+        if _is_windows() and part.exists():
+            try:
+                if part.stat().st_file_attributes & 0x400:  # FILE_ATTRIBUTE_REPARSE_POINT
+                    raise SetupError(f"refusing to write through reparse point: {part}")
+            except (OSError, AttributeError):
+                pass
+    return resolved
+
+
+def ensure_gitignore(path: Path, entries: list[str]) -> None:
+    """Append ignore entries before any secret/cache write. Idempotent.
+
+    Raises SetupError if a protected path is already tracked by git.
+    """
+    gi = path / ".gitignore"
+    existing = set(gi.read_text().splitlines()) if gi.exists() else set()
+    missing = [e for e in entries if e not in existing]
+    if missing:
+        with gi.open("a") as f:
+            for e in missing:
+                f.write(("\n" if existing else "") + e + "\n")
+            existing.update(missing)
+    _assert_not_tracked(path)
+
+
+def _assert_not_tracked(workdir: Path) -> None:
+    import subprocess
+
+    for rel in (AUTH_FILE_NAME, INDEX_DIR_NAME):
+        try:
+            r = subprocess.run(
+                ["git", "-C", str(workdir), "ls-files", "--error-unmatch", rel],
+                check=False, capture_output=True, timeout=10,
+            )
+        except (OSError, subprocess.SubprocessError):
+            return  # not a git repo / git absent — nothing tracked
+        if r.returncode == 0:
+            raise SetupError(
+                f"{rel} is already tracked by git — refusing to write secrets/cache there. "
+                f"Remove it from the index first: git rm --cached -r {rel}"
+            )
+
+
+@dataclass(frozen=True)
+class SiteProfile:
+    """A non-secret connection profile. Tokens live in a credential store."""
+
+    env: str            # "cloud" | "datacenter"
+    base_url: str       # canonical https base incl. context path (DC)
+    email: str | None   # cloud only
+    credential_ref: str # opaque key — not the token itself
+
+    @staticmethod
+    def canonical_base(env: str, raw_url: str) -> str:
+        u = urlparse(raw_url.strip())
+        if u.scheme not in ("https",) and u.hostname not in ("localhost", "127.0.0.1"):
+            raise SetupError("Confluence URL must be https (localhost allowed for tests only)")
+        if u.username or u.password:
+            raise SetupError("credentials must not be embedded in the URL")
+        base = f"{u.scheme}://{u.netloc}{u.path.rstrip('/')}"
+        if env == "cloud" and not re.search(r"\.atlassian\.net$", u.hostname or ""):
+            raise SetupError("cloud environment requires an *.atlassian.net site URL")
+        return base
+
+    def scope_key(self, principal: str, root_page_id: str) -> str:
+        """Partition identity: site + authenticated account + root page."""
+        raw = f"{self.base_url}|{principal}|{root_page_id}"
+        return hashlib.sha256(raw.encode()).hexdigest()[:24]
+
+    def save(self, home: Path) -> Path:
+        p = home / "profile.json"
+        p.parent.mkdir(parents=True, exist_ok=True)
+        tmp = p.with_suffix(".tmp")
+        tmp.write_text(json.dumps({
+            "env": self.env, "base_url": self.base_url,
+            "email": self.email, "credential_ref": self.credential_ref,
+        }, indent=2))
+        os.replace(tmp, p)  # atomic
+        return p
+
+    @staticmethod
+    def load(home: Path) -> SiteProfile:
+        p = home / "profile.json"
+        if not p.exists():
+            raise SetupError("no Confluence profile configured — run `confluence-knowledge setup`")
+        d = json.loads(p.read_text())
+        return SiteProfile(d["env"], d["base_url"], d.get("email"), d["credential_ref"])
+
+
+def extract_page_id(root: str) -> str:
+    """Accept a numeric ID or a Confluence page URL."""
+    if re.fullmatch(r"\d+", root.strip()):
+        return root.strip()
+    m = re.search(r"pageId=(\d+)", root) or re.search(r"/pages/(\d+)", root)
+    if m:
+        return m.group(1)
+    raise SetupError(
+        "can't resolve the root page ID from that URL — provide the numeric pageId "
+        "(open the page → Copy Link → look for pageId=…)"
+    )

confluence_knowledge-0.3.1.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: confluence-knowledge
+Version: 0.3.1
+Summary: Local, GET-only Confluence subtree indexer + grounded-Q&A MCP service
+License: MIT
+Project-URL: Repository, https://github.com/nkunal1992/agents
+Project-URL: Documentation, https://github.com/nkunal1992/agents/blob/main/docs/confluence-knowledge.md
+Project-URL: Issues, https://github.com/nkunal1992/agents/issues
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<0.29,>=0.27
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: numpy>=1.26
+Requires-Dist: keyring>=25.2
+Requires-Dist: mcp<2,>=1.6
+Requires-Dist: pip-system-certs>=5.0
+Provides-Extra: models
+Requires-Dist: sentence-transformers<4.0,>=3.0; extra == "models"
+Requires-Dist: huggingface-hub>=0.26; extra == "models"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+
+# confluence-knowledge (local MCP service)
+
+Local companion service for the `confluence-knowledge` Copilot agent.
+See `../../docs/confluence-knowledge.md` for the full guide.
+
+- GET-only `ConfluenceClient` — non-GET raises `SecurityException` pre-flight.
+- Recursive subtree crawl (Cloud v2 + Data Center), resumable.
+- Local embeddings (`all-MiniLM-L6-v2`) + local reranker
+  (`ms-marco-MiniLM-L6-v2`) — Apache-2.0, pinned in `models.lock.json`,
+  never a cloud embedding call.
+- SQLite + FTS5 + vector-blob index under `.conf_knowledge_index/`.
+- Credentials via OS keyring / env var / chmod-600 `.conf_auth.json`.
+
+## Dev
+
+```bash
+python3.11+ -m venv .venv && .venv/bin/pip install -e '.[dev]'
+.venv/bin/python -m pytest        # all offline — no network needed
+.venv/bin/python -m ruff check src tests
+```
+
+Before every release, run the end-to-end smoke test. It spawns the real stdio
+server through the MCP client SDK and uses the real models against a fake
+Confluence on localhost, with simulated network latency:
+
+```bash
+.venv/bin/pip install -e '.[models]'
+CONF_KNOWLEDGE_HOME=/tmp/ck/home .venv/bin/confluence-knowledge prepare-models
+CONF_KNOWLEDGE_HOME=/tmp/ck/home .venv/bin/python scripts/e2e_smoke.py   # ends with "E2E OK"
+```
+
+`e2e_bootstrap.py` goes further — it replays the agent's entire install flow
+in a sandboxed $HOME (python discovery → venv → `pip install` from the
+shipped `dist/` bundle → models → credentials → `register` → the real server
+over stdio → a full Q&A round-trip). Run it before every release:
+
+```bash
+CK_MODEL_CACHE=/tmp/ck/home/models .venv/bin/python scripts/e2e_bootstrap.py  # "E2E BOOTSTRAP OK"
+```
+
+## CLI
+
+| Command | Purpose |
+|---|---|
+| `confluence-knowledge setup` | guided env/site/token setup (hidden input, keyring) |
+| `confluence-knowledge prepare-models` | fetch pinned local models once |
+| `confluence-knowledge doctor` | verify config + heartbeat + models |
+| `confluence-knowledge serve` | run the stdio MCP server (what the IDE launches) |
+| `confluence-knowledge clean` | delete the local index (`~/.confluence-knowledge/work` unless `CONF_KNOWLEDGE_WORKDIR` is set) |

confluence_knowledge-0.3.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+confluence_knowledge/__init__.py,sha256=9NQCzCFTQ9AtKCldl_dQPCKLpnVZgOC7OWSrvXecSN0,107
+confluence_knowledge/auth.py,sha256=GSyfyxVT-HWIHDneNW2a3WzG31S8k_CZFdU3dvW1v5Y,2612
+confluence_knowledge/cli.py,sha256=kkTXadtO0Q1McXS2pwtwaFsVYp4w3BhHM0WVNMMZUO8,6771
+confluence_knowledge/client.py,sha256=OPDT4x8pNAhfCZ3DawJRDVPY8bDZHvZkhIXvuel90pA,6157
+confluence_knowledge/crawl.py,sha256=Oiqg1g_z2neS6byEpM3RpC0jJDdzqkXgLDFbBwzrI7M,9884
+confluence_knowledge/extract.py,sha256=zjPwx3Wc3h_OPIWEDBtpvlAay1XSRYIdigvBSdvv3qE,4211
+confluence_knowledge/index.py,sha256=r1sHyZvf6j9Dhm6bDl8sViaFjX0hy27NR1s4UFT3WQk,8692
+confluence_knowledge/models.lock.json,sha256=an-IDRAuNBSk4ooyuxugY-UsPYntolf2TvOdrD3pF8g,522
+confluence_knowledge/registration.py,sha256=r-EoLShv4SzQr5_ygmJpU8UifMGdZ_6vjuPW61mMTFY,4737
+confluence_knowledge/retrieval.py,sha256=SYoI4TYKKek6okKtU08nwtmpHKQIpqKbpXR2oVCEHwE,8139
+confluence_knowledge/server.py,sha256=LhSMV4SfI60skIal6WrVXqQftg8oxPEqZf0hLEk6SZI,11581
+confluence_knowledge/settings.py,sha256=sNDqBp-OIvp4aw6e7m6sxUYGZ4GZ17wnh-21rEI1nAU,5778
+confluence_knowledge-0.3.1.dist-info/METADATA,sha256=1eWgeNGnXOsmyUJOEDHhgWofMuT0GGwNExDSolkKQDU,3292
+confluence_knowledge-0.3.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+confluence_knowledge-0.3.1.dist-info/entry_points.txt,sha256=C7QwouYG11ah2TdR2bKpOFf2F9c91799_DFNT0ocrNE,71
+confluence_knowledge-0.3.1.dist-info/top_level.txt,sha256=oMELxCmqPUkKpODS3xuggz-ZMJbsow5L9EPF_4DhydU,21
+confluence_knowledge-0.3.1.dist-info/RECORD,,

confluence_knowledge-0.3.1.dist-info/WHEEL

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

confluence_knowledge-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+confluence-knowledge = confluence_knowledge.cli:main

confluence_knowledge-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+confluence_knowledge