drydock-cli 3.0.135__tar.gz → 3.0.136__tar.gz

{drydock_cli-3.0.135/drydock_cli.egg-info → drydock_cli-3.0.136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.135
+Version: 3.0.136
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -107,6 +107,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/graphrag add <path>` | Incrementally add more documents to the base |
 | `/graphrag query <q>` | Test what the base returns (no model) |
 | `/graphrag status` · `clear` | List indexed sources · wipe the base |
+| `/graphrag migrate` | Convert a legacy JSON index to the fast SQLite store |
 | `/skills` | List your skills |
 | `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
 | `/<name>` | Run a skill |
@@ -142,8 +143,8 @@ tool) when a question touches your material. Ingests text formats
 checklists (`.ckl`/`.cklb`)** — checklists are flattened to per-rule findings so
 you can ask "which findings are open?". `.docx`/`.ckl` need nothing extra; PDF
 uses the `pdftotext` binary (poppler) if present, else `pip install
-drydock-cli[pdf]` (pypdf). The index is a single JSON at
-`<project>/.drydock/graphrag.json` — clean-room, no embeddings.
+drydock-cli[pdf]` (pypdf). The index is a SQLite database at
+`<project>/.drydock/graphrag.db` (FTS5-indexed, so queries stay fast at multi-GB scale) — clean-room, no embeddings.
 
 ### Custom skills
 
@@ -260,6 +261,20 @@ LLM (llama.cpp/vLLM `:8000`, Ollama `:11434`, LM Studio `:1234`) and wires up
 the first one it finds — no account or API-key prompt. Override anytime with
 `--model` / `--provider` / `--base-url` or `~/.drydock/config.toml`.
 
+### Docker
+
+A prebuilt image is on Docker Hub. Drydock is just the agent — point it at your
+own OpenAI-compatible model server (e.g. one running on the host):
+
+```
+docker run -it --add-host=host.docker.internal:host-gateway \
+  -v "$PWD:/work" fbobe3/drydock \
+  --base-url http://host.docker.internal:8000/v1 --model gemma4
+```
+
+`-v "$PWD:/work"` mounts your project so the agent can read/edit it. Tags:
+`fbobe3/drydock:latest` and `fbobe3/drydock:<version>` (e.g. `:3.0.135`).
+
 ## Using it
 
 Type a task and press **Enter**. Drydock reads/writes/edits files and runs

{drydock_cli-3.0.135 → drydock_cli-3.0.136}/README.md

@@ -83,6 +83,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/graphrag add <path>` | Incrementally add more documents to the base |
 | `/graphrag query <q>` | Test what the base returns (no model) |
 | `/graphrag status` · `clear` | List indexed sources · wipe the base |
+| `/graphrag migrate` | Convert a legacy JSON index to the fast SQLite store |
 | `/skills` | List your skills |
 | `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
 | `/<name>` | Run a skill |
@@ -118,8 +119,8 @@ tool) when a question touches your material. Ingests text formats
 checklists (`.ckl`/`.cklb`)** — checklists are flattened to per-rule findings so
 you can ask "which findings are open?". `.docx`/`.ckl` need nothing extra; PDF
 uses the `pdftotext` binary (poppler) if present, else `pip install
-drydock-cli[pdf]` (pypdf). The index is a single JSON at
-`<project>/.drydock/graphrag.json` — clean-room, no embeddings.
+drydock-cli[pdf]` (pypdf). The index is a SQLite database at
+`<project>/.drydock/graphrag.db` (FTS5-indexed, so queries stay fast at multi-GB scale) — clean-room, no embeddings.
 
 ### Custom skills
 
@@ -236,6 +237,20 @@ LLM (llama.cpp/vLLM `:8000`, Ollama `:11434`, LM Studio `:1234`) and wires up
 the first one it finds — no account or API-key prompt. Override anytime with
 `--model` / `--provider` / `--base-url` or `~/.drydock/config.toml`.
 
+### Docker
+
+A prebuilt image is on Docker Hub. Drydock is just the agent — point it at your
+own OpenAI-compatible model server (e.g. one running on the host):
+
+```
+docker run -it --add-host=host.docker.internal:host-gateway \
+  -v "$PWD:/work" fbobe3/drydock \
+  --base-url http://host.docker.internal:8000/v1 --model gemma4
+```
+
+`-v "$PWD:/work"` mounts your project so the agent can read/edit it. Tags:
+`fbobe3/drydock:latest` and `fbobe3/drydock:<version>` (e.g. `:3.0.135`).
+
 ## Using it
 
 Type a task and press **Enter**. Drydock reads/writes/edits files and runs

{drydock_cli-3.0.135 → drydock_cli-3.0.136}/drydock/graphrag.py

@@ -25,10 +25,11 @@ from __future__ import annotations
 import json
 import os
 import re
+import sqlite3
 from collections import Counter, defaultdict
+from pathlib import Path
 
 from drydock import extract
-from pathlib import Path
 
 # Files we ingest as text. Everything else (binaries, images) is skipped.
 _TEXT_EXT = {
@@ -59,8 +60,150 @@ _RE_WORD = re.compile(r"[a-zA-Z0-9_]+")
 
 
 def default_store_path(cwd: str) -> Path:
-    """Project-local index (travels with the project, easy to .gitignore)."""
-    return Path(cwd) / ".drydock" / "graphrag.json"
+    """Project-local index. SQLite so queries touch only matching rows (fast even
+    at multi-GB scale) instead of parsing a giant JSON on every query."""
+    return Path(cwd) / ".drydock" / "graphrag.db"
+
+
+def _resolve_store(store_path) -> Path:
+    """Given a requested store path, return the one that actually exists — a
+    ``.db`` (SQLite) if present, else a legacy ``.json`` sibling, else the path
+    as given (a fresh build will create it)."""
+    p = Path(store_path)
+    if p.exists():
+        return p
+    db = p.with_suffix(".db")
+    if db.exists():
+        return db
+    js = p.with_suffix(".json")
+    if js.exists():
+        return js
+    return p
+
+
+# ── SQLite + FTS5 backend (the scalable store) ────────────────────────────
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS chunks(id INTEGER PRIMARY KEY, source TEXT, text TEXT);
+CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(text, content='chunks', content_rowid='id');
+CREATE TABLE IF NOT EXISTS entities(entity TEXT, chunk_id INTEGER);
+CREATE INDEX IF NOT EXISTS idx_entity ON entities(entity);
+CREATE TABLE IF NOT EXISTS edges(a TEXT, b TEXT, weight INTEGER);
+CREATE INDEX IF NOT EXISTS idx_edge_a ON edges(a);
+CREATE TABLE IF NOT EXISTS meta(key TEXT PRIMARY KEY, value TEXT);
+"""
+
+_FTS_STRIP = re.compile(r'[^A-Za-z0-9_ ]+')
+
+
+def _is_sqlite(path) -> bool:
+    return str(path).endswith(".db")
+
+
+def _write_sqlite(store_path, chunks, entity_chunks, edges) -> None:
+    """(Re)build the SQLite store from the accumulated chunks/entities/edges."""
+    sp = Path(store_path)
+    sp.parent.mkdir(parents=True, exist_ok=True)
+    if sp.exists():
+        sp.unlink()
+    con = sqlite3.connect(str(sp))
+    try:
+        con.executescript(_SCHEMA)
+        con.executemany("INSERT INTO chunks(id,source,text) VALUES(?,?,?)",
+                        ((c["id"], c["source"], c["text"]) for c in chunks))
+        con.executemany("INSERT INTO chunks_fts(rowid,text) VALUES(?,?)",
+                        ((c["id"], c["text"]) for c in chunks))
+        con.executemany("INSERT INTO entities(entity,chunk_id) VALUES(?,?)",
+                        ((e, cid) for e, cids in entity_chunks.items() for cid in cids))
+        con.executemany("INSERT INTO edges(a,b,weight) VALUES(?,?,?)",
+                        ((a, b, w) for a, nbrs in edges.items() for b, w in nbrs.items()))
+        con.execute("INSERT OR REPLACE INTO meta(key,value) VALUES('version','2')")
+        con.commit()
+    finally:
+        con.close()
+
+
+def _fts_query(words) -> str:
+    """Build a safe FTS5 MATCH expression (OR of quoted terms)."""
+    terms = []
+    for w in words:
+        w = _FTS_STRIP.sub(" ", w).strip()
+        if w:
+            terms.append('"' + w + '"')
+    return " OR ".join(terms)
+
+
+def _query_sqlite(store_path, query: str, k: int, hops: bool) -> dict:
+    """Fast query: FTS5 full-text over chunk text + indexed entity/graph lookups.
+    Loads only the matching rows — no full-file parse."""
+    con = sqlite3.connect(str(store_path))
+    con.row_factory = sqlite3.Row
+    cur = con.cursor()
+    try:
+        q_entities = set(extract_entities(query))
+        q_words = {w for w in (w.lower() for w in _RE_WORD.findall(query))
+                   if len(w) > 2 and w not in _STOPWORDS}
+        scores: dict[int, float] = defaultdict(float)
+
+        # 1) FTS5 keyword retrieval (indexed, bm25-ranked) — the main recall path.
+        expr = _fts_query(q_words)
+        if expr:
+            try:
+                rows = cur.execute(
+                    "SELECT rowid, rank FROM chunks_fts WHERE chunks_fts MATCH ? "
+                    "ORDER BY rank LIMIT 400", (expr,)).fetchall()
+                for r in rows:
+                    scores[r["rowid"]] += 0.5 + min(2.0, -float(r["rank"]) / 4.0)
+            except sqlite3.OperationalError:
+                pass
+
+        # 2) Exact entity hits (indexed) weigh most; collect matched entities.
+        matched: set[str] = set()
+        cand = {e.lower() for e in q_entities} | q_words
+        for qe in cand:
+            for r in cur.execute("SELECT chunk_id, entity FROM entities WHERE entity=?", (qe,)):
+                scores[r["chunk_id"]] += 3.0
+                matched.add(r["entity"])
+
+        # 3) 1-hop graph expansion over the strongest neighbors of matched entities.
+        related: list[str] = []
+        if hops and matched:
+            for e in list(matched):
+                nbrs = cur.execute("SELECT b, weight FROM edges WHERE a=? ORDER BY weight DESC LIMIT 5",
+                                   (e,)).fetchall()
+                for nb in nbrs:
+                    if nb["b"] not in matched:
+                        related.append(nb["b"])
+                        for r in cur.execute("SELECT chunk_id FROM entities WHERE entity=?", (nb["b"],)):
+                            scores[r["chunk_id"]] += 1.0
+
+        if not scores:
+            return {"chunks": [], "related": []}
+        ranked = sorted(scores.items(), key=lambda kv: -kv[1])[:k]
+        out = []
+        for cid, sc in ranked:
+            if sc <= 0:
+                continue
+            row = cur.execute("SELECT source, text FROM chunks WHERE id=?", (cid,)).fetchone()
+            if row:
+                out.append({"source": row["source"], "text": row["text"], "score": round(sc, 1)})
+        seen: set[str] = set()
+        rel_unique = [r for r in related if not (r in seen or seen.add(r))][:12]
+        return {"chunks": out, "related": rel_unique}
+    finally:
+        con.close()
+
+
+def migrate_json_to_sqlite(json_path, db_path) -> dict:
+    """One-time conversion of a legacy JSON index to the SQLite store. Loads the
+    JSON once (slow for a huge file, but one-time), then queries are fast."""
+    data = json.loads(Path(json_path).read_text("utf-8"))
+    chunks = data.get("chunks", [])
+    entity_chunks = {e: list(cids) for e, cids in data.get("entities", {}).items()}
+    edges = {a: dict(nbrs) for a, nbrs in data.get("edges", {}).items()}
+    _write_sqlite(db_path, chunks, entity_chunks, edges)
+    return {"chunks": len(chunks), "entities": len(entity_chunks),
+            "edges": sum(len(n) for n in edges.values())}
 
 
 def extract_entities(text: str) -> list[str]:
@@ -167,15 +310,22 @@ def _ingest_files(paths, cwd, chunks, entity_chunks, edges, skip_sources):
 
 
 def _save(store_path, chunks, entity_chunks, edges, files_added):
-    index = {
-        "version": 1,
-        "chunks": chunks,
-        "entities": {e: sorted(cids) for e, cids in entity_chunks.items()},
-        "edges": {a: dict(nbrs) for a, nbrs in edges.items()},
-    }
-    sp = Path(store_path)
-    sp.parent.mkdir(parents=True, exist_ok=True)
-    sp.write_text(json.dumps(index), encoding="utf-8")
+    # SQLite by default (scalable). A caller can still target a .json path
+    # explicitly (small/portable indexes, tests) and get the legacy format.
+    if _is_sqlite(store_path):
+        _write_sqlite(store_path, chunks,
+                      {e: sorted(cids) for e, cids in entity_chunks.items()},
+                      {a: dict(nbrs) for a, nbrs in edges.items()})
+    else:
+        index = {
+            "version": 1,
+            "chunks": chunks,
+            "entities": {e: sorted(cids) for e, cids in entity_chunks.items()},
+            "edges": {a: dict(nbrs) for a, nbrs in edges.items()},
+        }
+        sp = Path(store_path)
+        sp.parent.mkdir(parents=True, exist_ok=True)
+        sp.write_text(json.dumps(index), encoding="utf-8")
     return {
         "files": files_added,
         "chunks": len(chunks),
@@ -194,13 +344,36 @@ def build_index(paths: list[str], store_path: str | Path, *, cwd: str = ".") ->
     return _save(store_path, chunks, entity_chunks, edges, added)
 
 
+def _read_all(store_path) -> dict:
+    """Read a whole index into a dict (chunks/entities/edges) — used by add_to_index
+    to append. Handles both the SQLite store and a legacy JSON file."""
+    sp = _resolve_store(store_path)
+    if _is_sqlite(sp):
+        con = sqlite3.connect(str(sp))
+        con.row_factory = sqlite3.Row
+        try:
+            chunks = [{"id": r["id"], "source": r["source"], "text": r["text"]}
+                      for r in con.execute("SELECT id,source,text FROM chunks")]
+            entities: dict[str, list[int]] = defaultdict(list)
+            for r in con.execute("SELECT entity,chunk_id FROM entities"):
+                entities[r["entity"]].append(r["chunk_id"])
+            edges: dict[str, dict] = defaultdict(dict)
+            for r in con.execute("SELECT a,b,weight FROM edges"):
+                edges[r["a"]][r["b"]] = r["weight"]
+            return {"chunks": chunks, "entities": entities, "edges": edges}
+        finally:
+            con.close()
+    return json.loads(Path(sp).read_text("utf-8"))
+
+
 def add_to_index(paths: list[str], store_path: str | Path, *, cwd: str = ".") -> dict:
     """Incrementally ADD documents to an existing index (build it if none yet).
     Files already indexed (by relative path) are skipped — clear+build to refresh
     changed files. Returns {files (added), chunks, entities, edges} totals."""
-    existing = load_index(store_path)
-    if existing is None:
+    sp = _resolve_store(store_path)
+    if not sp.exists():
         return build_index(paths, store_path, cwd=cwd)
+    existing = _read_all(sp)
     chunks: list[dict] = list(existing.get("chunks", []))
     entity_chunks: dict[str, set[int]] = defaultdict(set)
     for e, cids in existing.get("entities", {}).items():
@@ -210,20 +383,50 @@ def add_to_index(paths: list[str], store_path: str | Path, *, cwd: str = ".") ->
         edges[a] = Counter(nbrs)
     skip = {c["source"] for c in chunks}
     added = _ingest_files(paths, cwd, chunks, entity_chunks, edges, skip)
-    return _save(store_path, chunks, entity_chunks, edges, added)
+    return _save(sp, chunks, entity_chunks, edges, added)
 
 
 def sources(index: dict) -> list[str]:
-    """The distinct source files in an index, sorted."""
+    """The distinct source files in an index, sorted. Accepts a loaded JSON dict
+    OR a SQLite handle ({'_db': path})."""
+    db = index.get("_db")
+    if db:
+        con = sqlite3.connect(str(db))
+        try:
+            return sorted(r[0] for r in con.execute("SELECT DISTINCT source FROM chunks"))
+        finally:
+            con.close()
     return sorted({c["source"] for c in index.get("chunks", [])})
 
 
-def load_index(store_path: str | Path) -> dict | None:
-    sp = Path(store_path)
+def index_stats(index: dict) -> dict:
+    """{chunks, entities} counts for a loaded dict OR a SQLite handle — without
+    reading a large index into memory."""
+    db = index.get("_db")
+    if db:
+        con = sqlite3.connect(str(db))
+        try:
+            c = con.execute("SELECT COUNT(*) FROM chunks").fetchone()[0]
+            e = con.execute("SELECT COUNT(DISTINCT entity) FROM entities").fetchone()[0]
+            return {"chunks": c, "entities": e}
+        finally:
+            con.close()
+    return {"chunks": len(index.get("chunks", [])), "entities": len(index.get("entities", {}))}
+
+
+def load_index(store_path: str | Path):
+    """Return a query handle for the index at store_path, or None if none exists.
+
+    For the SQLite store this is a tiny handle ({'_db': path}) — it does NOT read
+    the data (queries hit the DB directly, so a multi-GB index stays instant). For
+    a legacy JSON file it loads the dict (small/portable indexes)."""
+    sp = _resolve_store(store_path)
     if not sp.exists():
         return None
+    if _is_sqlite(sp):
+        return {"_db": str(sp)}
     try:
-        return json.loads(sp.read_text("utf-8"))
+        return json.loads(Path(sp).read_text("utf-8"))
     except (OSError, ValueError):
         return None
 
@@ -233,6 +436,11 @@ def query_index(index: dict, query: str, *, k: int = 5, hops: bool = True) -> di
 
     Returns {chunks: [{source, text, score}], related: [entities]}.
     """
+    # SQLite handle → the fast, indexed path (no full-file load).
+    db = index.get("_db")
+    if db:
+        return _query_sqlite(db, query, k, hops)
+
     chunks = index.get("chunks", [])
     entities = index.get("entities", {})
     edges = index.get("edges", {})

{drydock_cli-3.0.135 → drydock_cli-3.0.136}/drydock/tui/app.py

@@ -1125,23 +1125,43 @@ class DrydockApp(App):
                 self._info("No knowledge base yet. Build one:  /graphrag build <path>")
             else:
                 srcs = graphrag.sources(index)
+                st = graphrag.index_stats(index)
                 shown = "\n".join(f"    · {s}" for s in srcs[:20])
                 more = f"\n    … +{len(srcs) - 20} more" if len(srcs) > 20 else ""
+                resolved = graphrag._resolve_store(store)
+                legacy = "  ⚠ legacy JSON — run /graphrag migrate for fast queries" \
+                    if str(resolved).endswith(".json") else ""
                 self._info(
-                    f"Knowledge base: {len(index.get('chunks', []))} chunks · "
-                    f"{len(index.get('entities', {}))} entities · {len(srcs)} sources "
-                    f"({store}).\n{shown}{more}"
+                    f"Knowledge base: {st['chunks']} chunks · {st['entities']} entities · "
+                    f"{len(srcs)} sources ({resolved}).{legacy}\n{shown}{more}"
                 )
+        elif sub == "migrate":
+            resolved = graphrag._resolve_store(store)
+            if not str(resolved).endswith(".json"):
+                self._info("Already using the fast SQLite store — nothing to migrate.")
+                return
+            db = resolved.with_suffix(".db")
+            self._info(f"Migrating legacy index → {db} (one-time; loads the JSON once) …")
+            try:
+                m = graphrag.migrate_json_to_sqlite(resolved, db)
+            except Exception as e:  # noqa: BLE001
+                self._mount(ErrorMessage(f"migrate failed: {e}"))
+                return
+            self._info(
+                f"✓ Migrated: {m['chunks']} chunks · {m['entities']} entities → {db}. "
+                f"Queries now hit the index directly (no full-file load). You can delete "
+                f"the old {resolved.name} once you've confirmed queries work."
+            )
         elif sub == "clear":
             try:
-                store.unlink(missing_ok=True)
+                graphrag._resolve_store(store).unlink(missing_ok=True)
                 self._info("Knowledge base cleared.")
             except OSError as e:
                 self._mount(ErrorMessage(f"could not clear: {e}"))
         else:
             self._info(
                 "usage:  /graphrag build <path>  ·  add <path>  ·  query <question>  "
-                "·  status  ·  clear"
+                "·  status  ·  migrate  ·  clear"
             )
 
     def _persist_config(self) -> None:

{drydock_cli-3.0.135 → drydock_cli-3.0.136/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.135
+Version: 3.0.136
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -107,6 +107,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/graphrag add <path>` | Incrementally add more documents to the base |
 | `/graphrag query <q>` | Test what the base returns (no model) |
 | `/graphrag status` · `clear` | List indexed sources · wipe the base |
+| `/graphrag migrate` | Convert a legacy JSON index to the fast SQLite store |
 | `/skills` | List your skills |
 | `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
 | `/<name>` | Run a skill |
@@ -142,8 +143,8 @@ tool) when a question touches your material. Ingests text formats
 checklists (`.ckl`/`.cklb`)** — checklists are flattened to per-rule findings so
 you can ask "which findings are open?". `.docx`/`.ckl` need nothing extra; PDF
 uses the `pdftotext` binary (poppler) if present, else `pip install
-drydock-cli[pdf]` (pypdf). The index is a single JSON at
-`<project>/.drydock/graphrag.json` — clean-room, no embeddings.
+drydock-cli[pdf]` (pypdf). The index is a SQLite database at
+`<project>/.drydock/graphrag.db` (FTS5-indexed, so queries stay fast at multi-GB scale) — clean-room, no embeddings.
 
 ### Custom skills
 
@@ -260,6 +261,20 @@ LLM (llama.cpp/vLLM `:8000`, Ollama `:11434`, LM Studio `:1234`) and wires up
 the first one it finds — no account or API-key prompt. Override anytime with
 `--model` / `--provider` / `--base-url` or `~/.drydock/config.toml`.
 
+### Docker
+
+A prebuilt image is on Docker Hub. Drydock is just the agent — point it at your
+own OpenAI-compatible model server (e.g. one running on the host):
+
+```
+docker run -it --add-host=host.docker.internal:host-gateway \
+  -v "$PWD:/work" fbobe3/drydock \
+  --base-url http://host.docker.internal:8000/v1 --model gemma4
+```
+
+`-v "$PWD:/work"` mounts your project so the agent can read/edit it. Tags:
+`fbobe3/drydock:latest` and `fbobe3/drydock:<version>` (e.g. `:3.0.135`).
+
 ## Using it
 
 Type a task and press **Enter**. Drydock reads/writes/edits files and runs

{drydock_cli-3.0.135 → drydock_cli-3.0.136}/drydock_cli.egg-info/SOURCES.txt

@@ -96,6 +96,7 @@ tests/test_glob_edit_edges.py
 tests/test_graphify_example.py
 tests/test_graphrag.py
 tests/test_graphrag_quoted_path.py
+tests/test_graphrag_sqlite.py
 tests/test_grep_and_read_robust.py
 tests/test_guards_and_tools.py
 tests/test_hallucinated_tools.py

{drydock_cli-3.0.135 → drydock_cli-3.0.136}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.135"
+version = "3.0.136"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.136/tests/test_graphrag_sqlite.py

@@ -0,0 +1,70 @@
+"""GraphRAG SQLite+FTS5 backend: scalable store that queries only matching rows
+(no full-file load), with legacy-JSON migration."""
+from __future__ import annotations
+
+import os
+import tempfile
+
+from drydock import graphrag as g
+
+
+def _docs():
+    d = tempfile.mkdtemp()
+    docs = os.path.join(d, "docs"); os.makedirs(docs)
+    open(os.path.join(docs, "a.md"), "w").write(
+        "# Auth\nThe TokenValidator checks JWT expiry. Refunds via the BillingService.")
+    open(os.path.join(docs, "b.md"), "w").write(
+        "# Billing\nThe BillingService issues refunds within 30 days.")
+    return d, docs
+
+
+def test_default_store_is_sqlite():
+    assert str(g.default_store_path("/x")).endswith(".db")
+
+
+def test_build_query_sqlite():
+    d, docs = _docs()
+    store = os.path.join(d, ".drydock", "graphrag.db")
+    stats = g.build_index([docs], store, cwd=d)
+    assert stats["chunks"] == 2 and os.path.exists(store)
+    idx = g.load_index(store)
+    assert idx == {"_db": store}                     # lazy handle, not the data
+    r = g.query_index(idx, "how are refunds handled", k=3)
+    assert r["chunks"] and any("refund" in c["text"].lower() for c in r["chunks"])
+    assert g.sources(idx) == ["docs/a.md", "docs/b.md"]
+    assert g.index_stats(idx)["chunks"] == 2
+
+
+def test_add_to_sqlite_appends():
+    d, docs = _docs()
+    store = os.path.join(d, ".drydock", "graphrag.db")
+    g.build_index([docs], store, cwd=d)
+    open(os.path.join(docs, "c.md"), "w").write("# Refund policy\nPartial refunds allowed after 30 days.")
+    s2 = g.add_to_index([docs], store, cwd=d)
+    assert s2["files"] == 1 and s2["chunks"] == 3
+    r = g.query_index(g.load_index(store), "partial refund policy", k=3)
+    assert any(c["source"] == "docs/c.md" for c in r["chunks"])
+
+
+def test_migrate_json_to_sqlite():
+    d, docs = _docs()
+    js = os.path.join(d, "old.json")
+    g.build_index([docs], js, cwd=d)                 # explicit .json → legacy format
+    assert os.path.getsize(js) > 0
+    db = os.path.join(d, "new.db")
+    m = g.migrate_json_to_sqlite(js, db)
+    assert m["chunks"] == 2 and os.path.exists(db)
+    r = g.query_index(g.load_index(db), "refunds", k=2)
+    assert r["chunks"]
+
+
+def test_resolve_prefers_db_then_json():
+    d, docs = _docs()
+    base = os.path.join(d, ".drydock", "graphrag.db")
+    g.build_index([docs], base, cwd=d)
+    # asking for the .json path resolves to the existing .db
+    assert str(g._resolve_store(base.replace(".db", ".json"))).endswith(".db")
+
+
+def test_missing_store_returns_none():
+    assert g.load_index("/no/such/graphrag.db") is None