drydock-cli 3.0.59__tar.gz → 3.0.60__tar.gz

{drydock_cli-3.0.59/drydock_cli.egg-info → drydock_cli-3.0.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.59
+Version: 3.0.60
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.59 → drydock_cli-3.0.60}/drydock/cli.py

@@ -198,17 +198,23 @@ def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
         parts = raw.split()  # raw = case-preserved, so paths survive
         sub = parts[1].lower() if len(parts) > 1 else ""
         rest = " ".join(parts[2:]).strip()
-        if sub == "build" and rest:
-            print_colored(f"  Building knowledge base from {rest} …", "dim")
+        if sub in ("build", "add") and rest:
             try:
-                stats = graphrag.build_index([rest], store, cwd=cwd)
+                fn = graphrag.build_index if sub == "build" else graphrag.add_to_index
+                stats = fn([rest], store, cwd=cwd)
                 print_colored(
-                    f"  ✓ {stats['files']} files · {stats['chunks']} chunks · "
+                    f"  ✓ {sub}: +{stats['files']} files · {stats['chunks']} chunks · "
                     f"{stats['entities']} entities · {stats['edges']} edges → {store}",
                     "green",
                 )
             except Exception as e:  # noqa: BLE001
-                print_colored(f"  graphrag build failed: {e}", "red")
+                print_colored(f"  graphrag {sub} failed: {e}", "red")
+        elif sub == "query" and rest:
+            index = graphrag.load_index(store)
+            if index is None:
+                print_colored("  No knowledge base. Build: /graphrag build <path>", "dim")
+            else:
+                print(graphrag.format_results(graphrag.query_index(index, rest, k=3), rest))
         elif sub == "clear":
             store.unlink(missing_ok=True)
             print_colored("  Knowledge base cleared.", "green")
@@ -217,9 +223,11 @@ def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
             if index is None:
                 print_colored("  No knowledge base. Build: /graphrag build <path>", "dim")
             else:
+                srcs = graphrag.sources(index)
                 print_colored(
                     f"  Knowledge base: {len(index.get('chunks', []))} chunks · "
-                    f"{len(index.get('entities', {}))} entities ({store})", "cyan")
+                    f"{len(index.get('entities', {}))} entities · {len(srcs)} sources "
+                    f"({store})", "cyan")
         return True
     elif cmd in ("/quit", "/exit"):
         raise KeyboardInterrupt

{drydock_cli-3.0.59 → drydock_cli-3.0.60}/drydock/graphrag.py

@@ -110,26 +110,23 @@ def _iter_text_files(paths: list[str]):
                         yield fp
 
 
-def build_index(paths: list[str], store_path: str | Path, *, cwd: str = ".") -> dict:
-    """Build (or rebuild) the knowledge graph from paths; persist to store_path.
-
-    Returns a stats dict: {files, chunks, entities, edges}.
-    """
-    chunks: list[dict] = []
-    entity_chunks: dict[str, set[int]] = defaultdict(set)
-    edges: dict[str, Counter] = defaultdict(Counter)
-    files = 0
-
+def _ingest_files(paths, cwd, chunks, entity_chunks, edges, skip_sources):
+    """Chunk + extract + graph every text file under paths into the (mutable)
+    accumulators, skipping any source already present. Returns files added."""
+    added = 0
     for fp in _iter_text_files([str(Path(cwd) / p) if not os.path.isabs(p) else p
                                 for p in paths]):
+        rel = os.path.relpath(str(fp), cwd)
+        if rel in skip_sources:
+            continue
         try:
             text = fp.read_text("utf-8", "ignore")
         except OSError:
             continue
         if not text.strip():
             continue
-        files += 1
-        rel = os.path.relpath(str(fp), cwd)
+        added += 1
+        skip_sources.add(rel)  # don't double-ingest the same file in one call
         for body in _chunk_text(text):
             cid = len(chunks)
             ents = extract_entities(body)
@@ -140,7 +137,10 @@ def build_index(paths: list[str], store_path: str | Path, *, cwd: str = ".") ->
                 for b in ents[i + 1:]:
                     edges[a][b] += 1
                     edges[b][a] += 1
+    return added
+
 
+def _save(store_path, chunks, entity_chunks, edges, files_added):
     index = {
         "version": 1,
         "chunks": chunks,
@@ -151,13 +151,47 @@ def build_index(paths: list[str], store_path: str | Path, *, cwd: str = ".") ->
     sp.parent.mkdir(parents=True, exist_ok=True)
     sp.write_text(json.dumps(index), encoding="utf-8")
     return {
-        "files": files,
+        "files": files_added,
         "chunks": len(chunks),
         "entities": len(entity_chunks),
         "edges": sum(len(v) for v in edges.values()) // 2,
     }
 
 
+def build_index(paths: list[str], store_path: str | Path, *, cwd: str = ".") -> dict:
+    """Build (or REBUILD from scratch) the knowledge graph from paths; persist to
+    store_path. Returns {files, chunks, entities, edges}."""
+    chunks: list[dict] = []
+    entity_chunks: dict[str, set[int]] = defaultdict(set)
+    edges: dict[str, Counter] = defaultdict(Counter)
+    added = _ingest_files(paths, cwd, chunks, entity_chunks, edges, set())
+    return _save(store_path, chunks, entity_chunks, edges, added)
+
+
+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:
+        return build_index(paths, store_path, cwd=cwd)
+    chunks: list[dict] = list(existing.get("chunks", []))
+    entity_chunks: dict[str, set[int]] = defaultdict(set)
+    for e, cids in existing.get("entities", {}).items():
+        entity_chunks[e] = set(cids)
+    edges: dict[str, Counter] = defaultdict(Counter)
+    for a, nbrs in existing.get("edges", {}).items():
+        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)
+
+
+def sources(index: dict) -> list[str]:
+    """The distinct source files in an index, sorted."""
+    return sorted({c["source"] for c in index.get("chunks", [])})
+
+
 def load_index(store_path: str | Path) -> dict | None:
     sp = Path(store_path)
     if not sp.exists():

{drydock_cli-3.0.59 → drydock_cli-3.0.60}/drydock/tui/app.py

@@ -490,8 +490,8 @@ class DrydockApp(App):
                 "  /stop            stop the running turn (or press Esc)\n"
                 "  /status          session model, cwd, turns, tokens\n"
                 "  /compact         shrink old context to free up the window\n"
-                "  /graphrag        build/query a knowledge base from your docs\n"
-                "                   /graphrag build <path> · /graphrag status · /graphrag clear\n"
+                "  /graphrag        ingest docs into a knowledge base the agent can use\n"
+                "                   build <path> · add <path> · query <q> · status · clear\n"
                 "  /skills          list your reusable /<name> skills\n"
                 "  /loop            /loop <count> <prompt> — repeat a prompt (Esc stops)\n"
                 "  /mcp             list connected MCP servers and their tools\n"
@@ -634,33 +634,52 @@ class DrydockApp(App):
         sub = parts[0].lower() if parts else ""
         rest = parts[1].strip() if len(parts) > 1 else ""
 
-        if sub == "build":
+        if sub in ("build", "add"):
             if not rest:
-                self._info("usage: /graphrag build <path>   (a file or directory of docs/code)")
+                self._info(f"usage: /graphrag {sub} <path>   (a file or directory of docs/code)")
                 return
-            self._info(f"Building knowledge base from {rest} …")
+            verb = "Rebuilding" if sub == "build" else "Ingesting into"
+            self._info(f"{verb} knowledge base from {rest} …")
             try:
-                stats = graphrag.build_index([rest], store, cwd=cwd)
+                fn = graphrag.build_index if sub == "build" else graphrag.add_to_index
+                stats = fn([rest], store, cwd=cwd)
             except Exception as e:  # noqa: BLE001 — surface, never crash the TUI
-                self._mount(ErrorMessage(f"graphrag build failed: {e}"))
+                self._mount(ErrorMessage(f"graphrag {sub} failed: {e}"))
+                return
+            if sub == "add" and stats["files"] == 0:
+                self._info(f"No new documents under {rest} (already indexed, or no text found).")
                 return
             if not stats["chunks"]:
                 self._info(f"No text found under {rest}. Nothing was indexed.")
                 return
+            verb2 = "built" if sub == "build" else f"updated (+{stats['files']} new files)"
             self._info(
-                f"✓ Knowledge base built: {stats['files']} files · "
-                f"{stats['chunks']} chunks · {stats['entities']} entities · "
-                f"{stats['edges']} edges.\nStored at {store}. The agent will now "
-                "use the Knowledge tool to draw on it."
+                f"✓ Knowledge base {verb2}: {stats['chunks']} chunks · "
+                f"{stats['entities']} entities · {stats['edges']} edges.\n"
+                f"Stored at {store}. The agent draws on it via the Knowledge tool."
             )
+        elif sub == "query":
+            if not rest:
+                self._info("usage: /graphrag query <question>   (test what the KB returns)")
+                return
+            index = graphrag.load_index(store)
+            if index is None:
+                self._info("No knowledge base yet. Build one:  /graphrag build <path>")
+                return
+            res = graphrag.query_index(index, rest, k=3)
+            self._info(graphrag.format_results(res, rest))
         elif sub in ("", "status"):
             index = graphrag.load_index(store)
             if index is None:
                 self._info("No knowledge base yet. Build one:  /graphrag build <path>")
             else:
+                srcs = graphrag.sources(index)
+                shown = "\n".join(f"    · {s}" for s in srcs[:20])
+                more = f"\n    … +{len(srcs) - 20} more" if len(srcs) > 20 else ""
                 self._info(
                     f"Knowledge base: {len(index.get('chunks', []))} chunks · "
-                    f"{len(index.get('entities', {}))} entities  ({store})."
+                    f"{len(index.get('entities', {}))} entities · {len(srcs)} sources "
+                    f"({store}).\n{shown}{more}"
                 )
         elif sub == "clear":
             try:
@@ -669,7 +688,10 @@ class DrydockApp(App):
             except OSError as e:
                 self._mount(ErrorMessage(f"could not clear: {e}"))
         else:
-            self._info("usage:  /graphrag build <path>  ·  /graphrag status  ·  /graphrag clear")
+            self._info(
+                "usage:  /graphrag build <path>  ·  add <path>  ·  query <question>  "
+                "·  status  ·  clear"
+            )
 
     def _persist_config(self) -> None:
         """Save the persistable settings (model/provider/base_url/… — save_file

{drydock_cli-3.0.59 → drydock_cli-3.0.60/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.59
+Version: 3.0.60
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.59 → drydock_cli-3.0.60}/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.59"
+version = "3.0.60"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.0.59 → drydock_cli-3.0.60}/tests/test_graphrag.py

@@ -73,3 +73,35 @@ import pytest  # noqa: E402
 def _make_corpus(tmp_path):
     _corpus(tmp_path)
     yield
+
+
+def test_add_to_index_is_incremental(tmp_path):
+    store = tmp_path / ".drydock" / "graphrag.json"
+    (tmp_path / "one.md").write_text("The Alpha service uses the Beacon token.")
+    s1 = graphrag.build_index(["one.md"], store, cwd=str(tmp_path))
+    assert s1["files"] == 1
+    # add a second doc — existing chunks preserved, new ones appended
+    (tmp_path / "two.md").write_text("The Gamma module writes to the Delta table.")
+    s2 = graphrag.add_to_index(["two.md"], store, cwd=str(tmp_path))
+    assert s2["files"] == 1                      # only the NEW file counted
+    assert s2["chunks"] > s1["chunks"]           # grew
+    idx = graphrag.load_index(store)
+    assert set(graphrag.sources(idx)) == {"one.md", "two.md"}
+    # both docs are queryable
+    assert graphrag.query_index(idx, "Beacon token")["chunks"][0]["source"] == "one.md"
+    assert graphrag.query_index(idx, "Delta table")["chunks"][0]["source"] == "two.md"
+
+
+def test_add_skips_already_indexed(tmp_path):
+    store = tmp_path / ".drydock" / "graphrag.json"
+    (tmp_path / "one.md").write_text("Alpha Beacon content here.")
+    graphrag.build_index(["one.md"], store, cwd=str(tmp_path))
+    s = graphrag.add_to_index(["one.md"], store, cwd=str(tmp_path))  # same file again
+    assert s["files"] == 0                        # nothing re-ingested
+
+
+def test_add_builds_when_no_index_yet(tmp_path):
+    store = tmp_path / ".drydock" / "graphrag.json"
+    (tmp_path / "x.md").write_text("Some Echo content.")
+    s = graphrag.add_to_index(["x.md"], store, cwd=str(tmp_path))
+    assert s["files"] == 1 and graphrag.load_index(store) is not None