local-knowledge 0.1.0__py3-none-any.whl

local_knowledge/__init__.py

@@ -0,0 +1 @@
+"""local-knowledge — local file/folder indexing + grounded Q&A MCP service."""

local_knowledge/cli_local.py

@@ -0,0 +1,92 @@
+"""local-knowledge CLI: doctor / prepare-models / register / serve / clean.
+
+No `setup` — there are no credentials to collect. connect() takes the path.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+from confluence_knowledge.retrieval import prepare_models
+from confluence_knowledge.settings import SetupError
+
+from .settings_local import (
+    APP_NAME,
+    INDEX_DIR_NAME,
+    home,
+    workdir,
+)
+
+WORKDIR_ENV = "LOCAL_KNOWLEDGE_WORKDIR"
+
+
+def _doctor() -> int:
+    from .server_local import status
+    s = status()
+    print(json.dumps(s, indent=2))
+    return 0
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(prog=APP_NAME)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("doctor", help="verify install + models")
+    sub.add_parser("prepare-models", help="download the pinned local models")
+    reg = sub.add_parser(
+        "register",
+        help="write this server into the IDE's MCP config (no manual paste)")
+    reg.add_argument("--ide", default="auto",
+                     choices=["auto", "all", "vscode", "jetbrains"])
+    reg.add_argument("--workspace", type=Path, default=None)
+    reg.add_argument("--remove", action="store_true")
+    sub.add_parser("serve", help="run the stdio MCP server")
+    clean = sub.add_parser("clean", help="delete the local index")
+    clean.add_argument("--yes", action="store_true")
+    args = ap.parse_args()
+
+    if args.cmd == "doctor":
+        sys.exit(_doctor())
+    if args.cmd == "prepare-models":
+        for line in prepare_models(home()):
+            print(line)
+        return
+    if args.cmd == "register":
+        from confluence_knowledge.registration import register
+        try:
+            wd = (Path(os.environ[WORKDIR_ENV]).expanduser().resolve()
+                  if os.environ.get(WORKDIR_ENV) else None)
+            results = register(ide=args.ide, workspace=args.workspace,
+                               workdir=wd, remove=args.remove,
+                               server_id=APP_NAME,
+                               module="local_knowledge.server_local",
+                               env_var=WORKDIR_ENV)
+        except SetupError as e:
+            print(f"error: {e}", file=sys.stderr)
+            sys.exit(2)
+        for path, action in results:
+            print(f"{action}: {path}")
+        if not args.remove:
+            print("\nReload your IDE so Copilot picks up the server, "
+                  "then re-ask the agent.")
+        return
+    if args.cmd == "serve":
+        from .server_local import main as serve
+        serve()
+        return
+    if args.cmd == "clean":
+        import shutil
+
+        target = workdir() / INDEX_DIR_NAME
+        if target.exists() and (args.yes or input(
+                f"delete {target}? [y/N] ").strip().lower() == "y"):
+            shutil.rmtree(target)
+            print("index deleted")
+        return
+
+
+if __name__ == "__main__":
+    main()

local_knowledge/crawl_local.py

@@ -0,0 +1,199 @@
+"""Durable, resumable filesystem crawl — one path (file or folder) → index.
+
+Same durable-queue/checkpoint contract as the Confluence crawler: progress
+survives interruption, the background worker runs to completion, and only a
+completed crawl publishes (a partial refresh never clobbers a good snapshot).
+Reads only — never writes, follows no symlinks outside the root.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import uuid
+from pathlib import Path
+
+from confluence_knowledge.extract_files import extract_file_chunks, is_secret_name
+from confluence_knowledge.index import Index
+from confluence_knowledge.settings import SetupError
+
+# dirs never worth indexing — noise or actively harmful to read
+SKIP_DIRS = {".git", ".hg", ".svn", "node_modules", "__pycache__", ".venv",
+             "venv", ".idea", ".vscode", "target", "dist", "build", ".tox"}
+MAX_FILE_BYTES = 25 * 1024 * 1024  # 25MB — bigger files get a warning, not a crash
+MAX_FILES = 20_000                  # guard against "pointed at $HOME" accidents
+
+
+def resolve_root(path: str) -> Path:
+    """Validate + canonicalize a user-supplied path (file or folder)."""
+    p = Path(path).expanduser()
+    if not p.exists():
+        raise SetupError(f"path does not exist: {path}")
+    return p.resolve()
+
+
+class LocalCrawler:
+    def __init__(self, index: Index, root: Path, embedder=None):
+        self.index = index
+        self.root = root      # realpath — everything indexed must live under it
+        self.embedder = embedder
+
+    def start(self) -> str:
+        job_id = uuid.uuid4().hex[:12]
+        self.index.abandon_running_jobs()
+        self.index.create_job(job_id, str(self.root))
+        first = f"dir:{self.root}" if self.root.is_dir() else f"file:{self.root}"
+        self.index.save_job(job_id, "running", [first], [])
+        return job_id
+
+    def _rel(self, path: Path) -> str:
+        try:
+            return str(path.relative_to(self.root.parent)).replace("\\", "/")
+        except ValueError:
+            return path.name
+
+    def _children(self, d: Path) -> tuple[list[str], list[str]]:
+        """(new queue entries, warnings) — guarded, secret-aware listing."""
+        out, warns = [], []
+        try:
+            entries = sorted(d.iterdir())
+        except (PermissionError, OSError) as e:
+            return out, [f"{self._rel(d)}: unreadable — {e}"]
+        for e in entries:
+            if e.is_symlink():
+                # resolve and refuse escape — a symlink inside the root that
+                # points outside is disclosed, never followed
+                try:
+                    rp = e.resolve()
+                except OSError:
+                    warns.append(f"{self._rel(e)}: broken symlink — skipped")
+                    continue
+                if self.root.is_dir() and not rp.is_relative_to(self.root):
+                    warns.append(f"{self._rel(e)}: symlink escapes the root — skipped")
+                    continue
+                e = rp
+            if e.is_dir():
+                if e.name in SKIP_DIRS or e.name.startswith(".git"):
+                    continue
+                out.append(f"dir:{e}")
+            elif e.is_file():
+                if is_secret_name(e.name):
+                    warns.append(f"{self._rel(e)}: looks like a secret — skipped")
+                    continue
+                out.append(f"file:{e}")
+        return out, warns
+
+    def _page(self, f: Path) -> tuple[dict, list]:
+        try:
+            st = f.stat()
+            if st.st_size > MAX_FILE_BYTES:
+                return ({"page_id": self._rel(f), "title": f.name,
+                         "url": f"file://{f}", "version": f"{st.st_mtime_ns}:{st.st_size}",
+                         "content_hash": "",
+                         "warnings": [f"file too large ({st.st_size} bytes) — skipped"]},
+                        [])
+            data = f.read_bytes()
+        except OSError as e:
+            raise SetupError(f"{self._rel(f)}: unreadable — {e}") from e
+        chunks, warns = extract_file_chunks(f.name, data)
+        content_hash = hashlib.sha256(data).hexdigest()
+        return ({"page_id": self._rel(f), "title": f.name,
+                 "url": f"file://{f}",
+                 "version": f"{st.st_mtime_ns}:{st.st_size}",
+                 "content_hash": content_hash,
+                 "warnings": warns},
+                chunks)
+
+    def _checkpoint(self, job_id, queue, errors, seen, levels, warns) -> None:
+        with self.index.lock, self.index.db:
+            self.index.db.execute("INSERT OR REPLACE INTO meta VALUES (?,?)",
+                                  (f"seen:{job_id}", json.dumps(sorted(seen))))
+            self.index.db.execute("INSERT OR REPLACE INTO meta VALUES (?,?)",
+                                  (f"levels:{job_id}", json.dumps(levels)))
+            self.index.db.execute("INSERT OR REPLACE INTO meta VALUES (?,?)",
+                                  (f"warns:{job_id}", json.dumps(warns)))
+            self.index.db.execute(
+                "UPDATE jobs SET queue=?, errors=? WHERE job_id=?",
+                (json.dumps(queue), json.dumps(errors), job_id))
+
+    def step(self, job_id: str) -> dict:
+        """Process the durable queue to completion — files are cheap; the
+        time-budget concern that drove Confluence's per-step cap doesn't apply
+        to filesystem reads, and the worker calls this unbounded anyway."""
+        job = self.index.job(job_id)
+        if job is None:
+            raise SetupError(f"unknown job {job_id}")
+        if job["state"] != "running":
+            return {"job_id": job_id, "state": job["state"],
+                    "remaining": len(job["queue"]), "errors": job["errors"]}
+
+        queue: list[str] = job["queue"]
+        errors: list[str] = job["errors"]
+        seen_raw = self.index.meta_get(f"seen:{job_id}")
+        seen: set[str] = set(json.loads(seen_raw)) if seen_raw else set()
+        levels_raw = self.index.meta_get(f"levels:{job_id}")
+        levels: dict[str, int] = (json.loads(levels_raw) if levels_raw else {})
+        warns_raw = self.index.meta_get(f"warns:{job_id}")
+        # deliberate skips (secrets, escaping symlinks, unreadable dirs) are
+        # disclosures — reported to the agent but not coverage-degrading errors
+        warns: list[str] = json.loads(warns_raw) if warns_raw else []
+        visited_dirs: set[str] = set()   # guards symlink/dir-graph cycles
+
+        processed = 0
+        while queue:
+            if len(seen) >= MAX_FILES:
+                errors.append(f"file cap reached ({MAX_FILES}) — remaining skipped")
+                queue.clear()
+                break
+            if processed:
+                self._checkpoint(job_id, queue, errors, seen, levels, warns)
+            entry = queue.pop(0)
+            # entries are "dir:<path>" / "file:<path>" — split on the PREFIX,
+            # not ':' (Windows paths contain their own drive colon)
+            is_dir_entry = entry.startswith("dir:")
+            path_s = entry[4:] if is_dir_entry else entry[5:]
+            path = Path(path_s)
+            if path_s in seen:
+                continue
+            processed += 1
+            if is_dir_entry:
+                real = str(path.resolve())
+                if real in visited_dirs:
+                    continue  # symlink/loop — directories aren't pages
+                visited_dirs.add(real)
+                kids, warns2 = self._children(path)
+                warns.extend(warns2)
+                queue.extend(k for k in kids
+                             if (k[4:] if k.startswith("dir:") else k[5:]) not in seen)
+                continue
+            try:
+                page, chunks = self._page(path)
+            except SetupError as e:
+                errors.append(str(e))
+                continue
+            rel = page["page_id"]
+            if rel in seen:
+                continue
+            for c in chunks:
+                c.chunk_id = f"{rel}:{page['content_hash'][:8]}:{c.ordinal}"
+            vecs = None
+            if self.embedder is not None and chunks:
+                vecs = self.embedder.embed(
+                    [f"{c.heading_path}\n{c.text}" for c in chunks])
+            self.index.upsert_page({
+                "page_id": rel, "parent_id": None, "title": page["title"],
+                "url": page["url"], "level": levels.get(rel, path_s.count("/")),
+                "version": page["version"], "content_hash": page["content_hash"],
+                "warnings": page["warnings"]}, chunks, vecs)
+            seen.add(rel)
+
+        # persist final seen/levels/warns too — the in-loop checkpoint runs
+        # before each item is processed, so the last item would undercount
+        self._checkpoint(job_id, queue, errors, seen, levels, warns)
+        self.index.publish(seen)
+        self.index.save_job(job_id, "done" if not queue else "running",
+                            queue, errors)
+        return {"job_id": job_id,
+                "state": "done" if not queue else "running",
+                "remaining": len(queue), "pages_seen": len(seen),
+                "errors": errors, "warnings": warns}

local_knowledge/server_local.py

@@ -0,0 +1,298 @@
+"""stdio MCP server for local-knowledge — the only surface the agent reaches.
+
+Same tool surface as confluence-knowledge minus the credential machinery:
+there is nothing to authenticate. Scope handles are opaque paths bound to the
+canonical realpath partition.
+"""
+
+from __future__ import annotations
+
+import logging
+import socket
+import threading
+
+from confluence_knowledge.client import AccessError, SecurityException
+from confluence_knowledge.index import Index
+from confluence_knowledge.retrieval import (
+    LocalEmbedder,
+    LocalReranker,
+    check_citations,
+    retrieve,
+)
+from confluence_knowledge.settings import SetupError
+from mcp.server.fastmcp import FastMCP
+
+from .crawl_local import LocalCrawler, resolve_root
+from .settings_local import APP_NAME, LocalProfile, home, index_root
+
+mcp = FastMCP("local-knowledge")
+
+_scopes: dict[str, dict] = {}
+_evidence_sets: dict[str, list[dict]] = {}
+_indexes: dict[str, Index] = {}
+_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 _index_for(scope_key: str) -> Index:
+    idx = _indexes.get(scope_key)
+    if idx is None:
+        idx = _indexes[scope_key] = Index(index_root() / f"{scope_key}.db")
+    return idx
+
+
+def _embedder():
+    global _EMBEDDER
+    with _model_lock:
+        if _EMBEDDER is None:
+            _EMBEDDER = LocalEmbedder(home(), APP_NAME)
+    return _EMBEDDER
+
+
+def _reranker():
+    global _RERANKER
+    with _model_lock:
+        if _RERANKER is None:
+            _RERANKER = LocalReranker(home(), APP_NAME)
+    return _RERANKER
+
+
+def _warm_models() -> None:
+    try:
+        _embedder()
+        _reranker()
+    except SetupError:
+        pass
+    finally:
+        _models_ready.set()
+
+
+def _start_warmup() -> None:
+    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:
+        parts = scope_handle.split(":", 2)
+        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 — no credentials exist for this agent."""
+    models = home() / "models"
+    try:
+        profile = LocalProfile.load()
+        cfg = {"root": profile.root_path, "device": profile.device}
+    except SetupError as e:
+        cfg = {"error": str(e)}
+    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(index_root()),
+        "live_scopes": sorted(_scopes),
+    }
+
+
+@mcp.tool()
+def connect(root: str) -> dict:
+    """Bind a scope to a file or folder path. No credentials needed — the
+    filesystem itself is the ACL (we can only read what the user can)."""
+    path = resolve_root(root)
+    profile = LocalProfile(str(path), socket.gethostname())
+    profile.save()          # remember last-used root for status/doctor
+    scope_key = profile.scope_key()
+    idx = _index_for(scope_key)
+    st = idx.stats()
+    handle = f"scope:{scope_key}:{path}"
+    _scopes[handle] = {"key": scope_key, "root": path}
+    _start_warmup()
+    return {
+        "scope_handle": handle,
+        "root": str(path),
+        "kind": "folder" if path.is_dir() else "file",
+        "cached": st["pages"] > 0,
+        "cached_pages": st["pages"],
+        "cached_as_of": st["as_of"],
+    }
+
+
+_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_ready.wait()
+        c = LocalCrawler(idx, s["root"], embedder=_embedder())
+        r = c.step(job_id)
+        while r["state"] == "running":
+            r = c.step(job_id)
+    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:
+    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 indexing the root (file or folder, recursive) in the background."""
+    s = _scope(scope_handle)
+    idx = _index_for(s["key"])
+    c = LocalCrawler(idx, s["root"])
+    job_id = c.start()
+    _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; resumes a dead worker automatically."""
+    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}")
+    def progress() -> dict:
+        p = idx.job_progress(job_id)
+        import json
+        warns = idx.meta_get(f"warns:{job_id}")
+        if warns:
+            p["warnings"] = json.loads(warns)
+        return p
+
+    if job["state"] == "running":
+        if not _models_ready.is_set():
+            _start_warmup()
+            note = LOADING_NOTE
+        else:
+            note = None
+        _ensure_worker(s, job_id)
+        p = progress()
+        if note:
+            p["note"] = note
+        return p
+    p = progress()
+    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 files indexed — run a crawl first"}
+    if not _models_loaded(10.0):
+        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:
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    _start_warmup()
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

local_knowledge/settings_local.py

@@ -0,0 +1,67 @@
+"""Filesystem layout for local-knowledge — ~/.local-knowledge, LOCAL_KNOWLEDGE_*.
+
+The engine is confluence_knowledge's settings machinery parametrized for the
+local connector; no credentials exist (connect reads only paths).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from confluence_knowledge.settings import (
+    SetupError,
+    default_home,
+    resolve_workdir,
+)
+
+APP_NAME = "local-knowledge"
+INDEX_DIR_NAME = ".local_knowledge_index"
+PROFILE_NAME = "profile.json"
+
+
+def home() -> Path:
+    return default_home("LOCAL_KNOWLEDGE_HOME", ".local-knowledge")
+
+
+def workdir() -> Path:
+    return resolve_workdir("LOCAL_KNOWLEDGE_WORKDIR",
+                           "LOCAL_KNOWLEDGE_HOME", ".local-knowledge")
+
+
+def index_root() -> Path:
+    return workdir() / INDEX_DIR_NAME
+
+
+@dataclass(frozen=True)
+class LocalProfile:
+    """A non-secret connect profile — just the root path that was indexed."""
+
+    root_path: str      # canonical realpath of the file/folder
+    device: str         # machine the path lives on (informational)
+
+    def scope_key(self) -> str:
+        raw = f"{self.root_path}|{self.device}"
+        return hashlib.sha256(raw.encode()).hexdigest()[:24]
+
+    def save(self) -> Path:
+        p = home() / PROFILE_NAME
+        p.parent.mkdir(parents=True, exist_ok=True)
+        tmp = p.with_suffix(".tmp")
+        tmp.write_text(json.dumps({
+            "root_path": self.root_path, "device": self.device,
+        }, indent=2))
+        os.replace(tmp, p)
+        return p
+
+    @staticmethod
+    def load() -> LocalProfile:
+        p = home() / PROFILE_NAME
+        if not p.exists():
+            raise SetupError("no local profile — run `local-knowledge connect` "
+                             "with a path via the agent, or `local-knowledge doctor`")
+        d = json.loads(p.read_text())
+        return LocalProfile(d["root_path"], d.get("device", "local"))

local_knowledge-0.1.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: local-knowledge
+Version: 0.1.0
+Summary: Local file/folder indexer + grounded-Q&A MCP service — same engine as confluence-knowledge, no credentials needed
+License: MIT
+Project-URL: Repository, https://github.com/nkunal1992/agents
+Project-URL: Documentation, https://github.com/nkunal1992/agents/blob/main/docs/local-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: confluence-knowledge>=0.4.0
+Requires-Dist: python-docx>=1.1
+Requires-Dist: pypdf>=4.0
+Requires-Dist: python-pptx>=1.0
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: mcp<2,>=1.6
+Requires-Dist: pip-system-certs>=5.0
+Provides-Extra: models
+Requires-Dist: confluence-knowledge[models]>=0.4.0; 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"
+
+# local-knowledge
+
+Local file/folder indexer + grounded-Q&A MCP service — the same engine as
+[`confluence-knowledge`](../confluence-knowledge), pointed at the filesystem
+instead of Confluence. No credentials, no HTTP.
+
+- `local_knowledge/crawl_local.py` — durable filesystem BFS (secret-file
+  exclusions, symlink-escape guards, checkpointed resume)
+- `local_knowledge/server_local.py` — the `local-knowledge/*` MCP tools
+- `local_knowledge/cli_local.py` — `local-knowledge` CLI (no `setup`; there's
+  nothing to authenticate)
+
+Shares `confluence_knowledge`'s index, extraction (`extract` +
+`extract_files`), retrieval, registration and auth plumbing.
+
+See `docs/local-knowledge.md` in the repo root for the full guide and
+`bundle/local-README.md` for the store-listing copy.

local_knowledge-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+local_knowledge/__init__.py,sha256=rreRBSwDo9eaGZBHs6idZUrXyNwH22MGS--mBeL3N3Y,81
+local_knowledge/cli_local.py,sha256=T5hOoexTxQoTZYyCSGtP35ki0a4PnCVFIpzn7eJKR34,2974
+local_knowledge/crawl_local.py,sha256=fOBadO-VPpJX_bqdpj8LV935CUicJ_odgyFEsI5-QQk,9134
+local_knowledge/server_local.py,sha256=Xh-iI0yJnYyoXUCw7fUB0JYwh0_r-lDYUNIgWODQukQ,9423
+local_knowledge/settings_local.py,sha256=YoHkz236ut6AoiG-Zl2NY_kYGqovEUOjKUxM4H14e2M,1983
+local_knowledge-0.1.0.dist-info/METADATA,sha256=cBrJ51KTCL7GM9XXqNRIL1fae0UEH55H1EnI2pblOVA,1940
+local_knowledge-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+local_knowledge-0.1.0.dist-info/entry_points.txt,sha256=f0GOJGe4zd6e4DiNrBp7Z6akVnaR9zur87-9bEJD9fc,67
+local_knowledge-0.1.0.dist-info/top_level.txt,sha256=-5WJHYmSUJKOgmdKScXvwxS7ND8OzSilB78sfAnwMlQ,16
+local_knowledge-0.1.0.dist-info/RECORD,,

local_knowledge-0.1.0.dist-info/WHEEL

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

local_knowledge-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+local-knowledge = local_knowledge.cli_local:main

local_knowledge-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+local_knowledge