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

{drydock_cli-3.0.134/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.134
+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
 
@@ -253,13 +254,27 @@ drydock
 ```
 
 Requires Python 3.11+. From source instead:
-`git clone https://github.com/fbobe321/drydock-v3.git && cd drydock-v3 && pip install -e .`
+`git clone https://github.com/fbobe321/drydock.git && cd drydock && pip install -e .`
 
 On first launch with no config, Drydock probes localhost for a running local
 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.134 → 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
 
@@ -229,13 +230,27 @@ drydock
 ```
 
 Requires Python 3.11+. From source instead:
-`git clone https://github.com/fbobe321/drydock-v3.git && cd drydock-v3 && pip install -e .`
+`git clone https://github.com/fbobe321/drydock.git && cd drydock && pip install -e .`
 
 On first launch with no config, Drydock probes localhost for a running local
 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.134 → drydock_cli-3.0.136}/drydock/cli.py

@@ -248,6 +248,27 @@ def _summarize(inputs: dict) -> str:
 
 # ── Entry point ───────────────────────────────────────────────────────────
 
+def _resolve_first_run(cfg: dict, args, cfg_path, cfgmod, interactive: bool) -> tuple[dict, str]:
+    """First-launch model-server resolution. AUTODETECT a live local server and
+    wire it up with ZERO prompts (the frictionless path). Only when nothing is
+    detected AND we're interactive do we ask the user to enter their own URL — so
+    the easy install (server already running) needs no input, while a custom
+    endpoint is still one prompt (or `--base-url`, or `/model url` later)."""
+    from drydock import detect
+
+    found = detect.detect_local_llms()
+    if found:
+        cfg["provider"] = found[0]["provider"]
+        cfg["base_url"] = found[0]["base_url"]
+        if found[0].get("models") and not getattr(args, "model", None):
+            cfg["model"] = found[0]["models"][0]
+        cfgmod.save_file(cfg, cfg_path)
+        return cfg, detect.onboarding_message(found)
+    if interactive:
+        return _first_run_setup(cfg, cfg_path, cfgmod)
+    return cfg, detect.onboarding_message(found)
+
+
 def _first_run_setup(cfg: dict, cfg_path, cfgmod) -> tuple[dict, str]:
     """Interactive first-launch: ask for the model server URL + model name and
     persist them to config.toml. Autodetect (if anything is listening) supplies
@@ -346,22 +367,11 @@ def main():
         "context_limit": args.context_limit,
     }, cfg_path)
 
-    # First launch: ask the user for their model server URL + model name and
-    # persist them to config.toml. Interactive only — when stdin isn't a TTY
-    # (piped / -p / cron) we fall back to silent autodetect so nothing blocks.
+    # First launch: autodetect a local server and wire it up (see _resolve_first_run).
     onboarding = ""
     if first_run and not args.provider and not args.base_url:
-        if sys.stdin.isatty() and not args.prompt:
-            cfg, onboarding = _first_run_setup(cfg, cfg_path, cfgmod)
-        else:
-            from drydock import detect
-
-            found = detect.detect_local_llms()
-            onboarding = detect.onboarding_message(found)
-            if found:
-                cfg["provider"] = found[0]["provider"]
-                cfg["base_url"] = found[0]["base_url"]
-                cfgmod.save_file(cfg, cfg_path)
+        interactive = sys.stdin.isatty() and not args.prompt
+        cfg, onboarding = _resolve_first_run(cfg, args, cfg_path, cfgmod, interactive)
 
     config = {
         # context_limit now comes from cfg (DEFAULTS < config.toml < --context-limit)

{drydock_cli-3.0.134 → 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.134 → 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.134 → 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.134
+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
 
@@ -253,13 +254,27 @@ drydock
 ```
 
 Requires Python 3.11+. From source instead:
-`git clone https://github.com/fbobe321/drydock-v3.git && cd drydock-v3 && pip install -e .`
+`git clone https://github.com/fbobe321/drydock.git && cd drydock && pip install -e .`
 
 On first launch with no config, Drydock probes localhost for a running local
 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.134 → 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.134 → 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.134"
+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.134 → drydock_cli-3.0.136}/tests/test_config_migration.py

@@ -77,8 +77,8 @@ def test_partial_config_backfills_missing_keys(tmp_path):
 
 
 def test_explicit_user_values_are_respected(tmp_path):
-    m = _load(tmp_path, 'base_url = "http://192.168.50.129:8000/v1"\nmodel = "gemma4"\n')
-    assert m["base_url"] == "http://192.168.50.129:8000/v1"
+    m = _load(tmp_path, 'base_url = "http://192.0.2.10:8000/v1"\nmodel = "gemma4"\n')
+    assert m["base_url"] == "http://192.0.2.10:8000/v1"
 
 
 def test_default_base_url_is_concrete_not_empty():
@@ -108,7 +108,7 @@ def test_v2_file_is_migrated_and_backed_up(tmp_path):
 def test_real_v3_file_is_left_untouched(tmp_path):
     """A genuine v3 file (has a known key) must NOT be migrated/rewritten."""
     p = tmp_path / "config.toml"
-    p.write_text('base_url = "http://192.168.50.21:8000/v1"\n# my hand edit\n')
+    p.write_text('base_url = "http://192.0.2.20:8000/v1"\n# my hand edit\n')
     cfg.resolve({}, path=p)
     assert not p.with_name("config.toml.bak").exists()
     assert "# my hand edit" in p.read_text()  # untouched