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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.59
+Version: 3.0.61
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -71,6 +71,52 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
   `~/.drydock/skills/` (or `<project>/.drydock/skills/`); `$ARGS` substitution.
 - **Loops** — `/loop <count> <prompt>` runs a prompt iteratively (Esc stops).
 
+## Slash commands
+
+Typed into the prompt. The agent also knows these, so you can just **ask it**
+("how do I add my own docs?") and it'll point you to the right one.
+
+| Command | What it does |
+| --- | --- |
+| `/graphrag build <path>` | Build a knowledge base from a file or folder of docs/code |
+| `/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 |
+| `/skills` | List your skills |
+| `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
+| `/<name>` | Run a skill |
+| `/loop <count> <prompt>` | Repeat a prompt N times (Esc stops) |
+| `/mcp` | List connected MCP servers + their tools |
+| `/model` · `/cwd` | Show/set model & endpoint · working directory |
+| `/undo` · `/back` | Revert the last write · rewind the last turn |
+| `/compact` · `/status` · `/clear` | Shrink context · session stats · reset |
+| `/help` · `/quit` | Help · exit |
+
+### Knowledge base (GraphRAG) — ingesting your documents
+
+```
+/graphrag build ./docs        # index a file or a whole folder
+/graphrag add ./more_docs     # add more later, incrementally
+/graphrag query "how are refunds handled?"   # check retrieval
+/graphrag status              # what's indexed
+```
+
+Once built, the agent **automatically** retrieves from it (read-only `Knowledge`
+tool) when a question touches your material. Ingests text formats
+(`.md .txt .py .js .json .yaml .sql …`); convert PDFs/Word to text first
+(e.g. `pdftotext file.pdf file.txt`). The index is a single JSON at
+`<project>/.drydock/graphrag.json` — clean-room, stdlib-only, no embeddings.
+
+### Custom skills
+
+```
+/skills new commitmsg  Write a concise conventional-commit message for: $ARGS
+/commitmsg the staged auth changes      # runs the skill with $ARGS substituted
+```
+
+Skills are markdown files in `~/.drydock/skills/` (personal) or
+`<project>/.drydock/skills/` (project); `/skills new` writes one for you.
+
 ## Install
 
 ```bash

{drydock_cli-3.0.59 → drydock_cli-3.0.61}/README.md

@@ -49,6 +49,52 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
   `~/.drydock/skills/` (or `<project>/.drydock/skills/`); `$ARGS` substitution.
 - **Loops** — `/loop <count> <prompt>` runs a prompt iteratively (Esc stops).
 
+## Slash commands
+
+Typed into the prompt. The agent also knows these, so you can just **ask it**
+("how do I add my own docs?") and it'll point you to the right one.
+
+| Command | What it does |
+| --- | --- |
+| `/graphrag build <path>` | Build a knowledge base from a file or folder of docs/code |
+| `/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 |
+| `/skills` | List your skills |
+| `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
+| `/<name>` | Run a skill |
+| `/loop <count> <prompt>` | Repeat a prompt N times (Esc stops) |
+| `/mcp` | List connected MCP servers + their tools |
+| `/model` · `/cwd` | Show/set model & endpoint · working directory |
+| `/undo` · `/back` | Revert the last write · rewind the last turn |
+| `/compact` · `/status` · `/clear` | Shrink context · session stats · reset |
+| `/help` · `/quit` | Help · exit |
+
+### Knowledge base (GraphRAG) — ingesting your documents
+
+```
+/graphrag build ./docs        # index a file or a whole folder
+/graphrag add ./more_docs     # add more later, incrementally
+/graphrag query "how are refunds handled?"   # check retrieval
+/graphrag status              # what's indexed
+```
+
+Once built, the agent **automatically** retrieves from it (read-only `Knowledge`
+tool) when a question touches your material. Ingests text formats
+(`.md .txt .py .js .json .yaml .sql …`); convert PDFs/Word to text first
+(e.g. `pdftotext file.pdf file.txt`). The index is a single JSON at
+`<project>/.drydock/graphrag.json` — clean-room, stdlib-only, no embeddings.
+
+### Custom skills
+
+```
+/skills new commitmsg  Write a concise conventional-commit message for: $ARGS
+/commitmsg the staged auth changes      # runs the skill with $ARGS substituted
+```
+
+Skills are markdown files in `~/.drydock/skills/` (personal) or
+`<project>/.drydock/skills/` (project); `/skills new` writes one for you.
+
 ## Install
 
 ```bash

{drydock_cli-3.0.59 → drydock_cli-3.0.61}/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.61}/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.61}/drydock/skills.py

@@ -77,6 +77,25 @@ def skills_dirs(cwd: str) -> list[Path]:
     return [Path.home() / ".drydock" / "skills", Path(cwd) / ".drydock" / "skills"]
 
 
+def create_skill(name: str, body: str, *, description: str = "", scope: str = "user",
+                 cwd: str = ".") -> Path:
+    """Author a new skill markdown file and return its path. scope='user' writes
+    to ~/.drydock/skills (available everywhere); scope='project' writes to
+    <cwd>/.drydock/skills. Raises ValueError on a bad name / empty body."""
+    name = (name or "").strip().lower()
+    body = (body or "").strip()
+    if not _NAME_RE.match(name):
+        raise ValueError("skill name must be letters/digits/-/_ (e.g. 'review')")
+    if not body:
+        raise ValueError("a skill needs a prompt body")
+    d = (Path(cwd) if scope == "project" else Path.home()) / ".drydock" / "skills"
+    d.mkdir(parents=True, exist_ok=True)
+    path = d / f"{name}.md"
+    front = f"---\nname: {name}\ndescription: {description or 'user skill'}\n---\n"
+    path.write_text(front + body + "\n", encoding="utf-8")
+    return path
+
+
 def load_skills(cwd: str) -> dict[str, Skill]:
     """Load all skills; later dirs (project) override earlier (user) by name."""
     skills: dict[str, Skill] = {}

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

@@ -490,9 +490,9 @@ 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"
-                "  /skills          list your reusable /<name> skills\n"
+                "  /graphrag        ingest docs into a knowledge base the agent can use\n"
+                "                   build <path> · add <path> · query <q> · status · clear\n"
+                "  /skills          list skills · /skills new <name> <prompt> to create one\n"
                 "  /loop            /loop <count> <prompt> — repeat a prompt (Esc stops)\n"
                 "  /mcp             list connected MCP servers and their tools\n"
                 "  /clear           reset the conversation\n"
@@ -504,7 +504,7 @@ class DrydockApp(App):
         elif cmd == "/loop":
             self._cmd_loop(arg)
         elif cmd == "/skills":
-            self._cmd_skills()
+            self._cmd_skills(arg)
         elif cmd[1:] in self._skills:
             self._run_skill(self._skills[cmd[1:]], arg)
         else:
@@ -554,19 +554,42 @@ class DrydockApp(App):
         self._mount(UserMessage(prompt))
         self._begin(prompt)
 
-    def _cmd_skills(self) -> None:
+    def _cmd_skills(self, arg: str = "") -> None:
+        """List skills, or create one: /skills new <name> <prompt…> (use $ARGS in
+        the prompt for trailing input). Created skills are usable as /<name>
+        immediately."""
+        from drydock import skills as skillsmod
+
+        parts = arg.split(maxsplit=2)
+        if parts and parts[0].lower() == "new":
+            if len(parts) < 3:
+                self._info(
+                    "usage: /skills new <name> <prompt text>\n"
+                    "  e.g.  /skills new review  Run GitDiff, then review the changes "
+                    "for bugs.\n  (use $ARGS in the prompt for trailing input)"
+                )
+                return
+            name, body = parts[1], parts[2]
+            try:
+                path = skillsmod.create_skill(name, body, cwd=self.config.get("cwd") or ".")
+            except ValueError as e:
+                self._info(f"Couldn't create skill: {e}")
+                return
+            self._skills = skillsmod.load_skills(self.config.get("cwd") or ".")  # reload
+            self._info(f"✓ Created skill /{name.lower()} ({path}). Invoke it as /{name.lower()}.")
+            return
         if not self._skills:
             self._info(
-                "No skills yet. Create one as a markdown file in "
-                "~/.drydock/skills/<name>.md (or <project>/.drydock/skills/), "
-                "then invoke it as /<name>. The body is the prompt; use $ARGS for "
-                "trailing input."
+                "No skills yet. Create one with:  /skills new <name> <prompt text>\n"
+                "(or drop a markdown file in ~/.drydock/skills/<name>.md). Invoke as "
+                "/<name>; use $ARGS for trailing input."
             )
             return
         lines = ["Skills (invoke as /<name>):"]
         for name in sorted(self._skills):
             sk = self._skills[name]
             lines.append(f"  /{name}" + (f"  — {sk.description}" if sk.description else ""))
+        lines.append("Create one:  /skills new <name> <prompt text>")
         self._info("\n".join(lines))
 
     def _run_skill(self, skill, arg: str) -> None:
@@ -634,33 +657,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 +711,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.61}/drydock/tuning.py

@@ -206,9 +206,33 @@ def filter_tool_schemas(tool_schemas: list, model: str | None) -> list:
     return [t for t in tool_schemas if t.get("name") not in GEMMA_DISABLED_TOOLS]
 
 
+# Reference for the model so it can answer "how do I …" questions about Drydock
+# itself. The user TYPES these slash commands; you (the model) do NOT run them —
+# you just explain the right one when asked. Appended to every system prompt.
+_DRYDOCK_COMMANDS_HELP = (
+    "\n\nAbout Drydock (the tool you run inside). If the user asks how to do "
+    "something with Drydock, tell them the slash command — they type it, you do "
+    "NOT run it:\n"
+    "- Knowledge base from their docs: `/graphrag build <path>` (a file or "
+    "folder), `/graphrag add <path>` to add more, `/graphrag query <q>` to test "
+    "it, `/graphrag status`, `/graphrag clear`. Once built, you automatically use "
+    "the `Knowledge` tool to draw on it. It ingests text formats (md/txt/code/"
+    "json/yaml/…); PDFs/Word must be converted to text first.\n"
+    "- Custom skills (reusable `/<name>` prompts): `/skills new <name> <prompt "
+    "text>` creates one (use $ARGS in the prompt for trailing input); `/skills` "
+    "lists them; then they run it as `/<name>`.\n"
+    "- Other: `/model` (model/endpoint), `/cwd`, `/undo` (revert last write), "
+    "`/back` (rewind a turn), `/compact` (shrink context), `/loop <n> <prompt>` "
+    "(repeat a prompt), `/mcp` (connected MCP servers), `/status`, `/clear`, "
+    "`/help`, `/quit`. Internet + git are tools you call yourself "
+    "(WebSearch/WebFetch, GitStatus/GitDiff/GitLog/GitCommit)."
+)
+
+
 def system_prompt_for_model(model: str | None) -> str:
     """Return the system prompt best suited to the model."""
-    return _GEMMA_SYSTEM_PROMPT if is_gemma(model) else _DEFAULT_SYSTEM_PROMPT
+    base = _GEMMA_SYSTEM_PROMPT if is_gemma(model) else _DEFAULT_SYSTEM_PROMPT
+    return base + _DRYDOCK_COMMANDS_HELP
 
 
 def thinking_level_for_turn(turn_count: int, is_user_turn: bool) -> str:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.59
+Version: 3.0.61
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -71,6 +71,52 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
   `~/.drydock/skills/` (or `<project>/.drydock/skills/`); `$ARGS` substitution.
 - **Loops** — `/loop <count> <prompt>` runs a prompt iteratively (Esc stops).
 
+## Slash commands
+
+Typed into the prompt. The agent also knows these, so you can just **ask it**
+("how do I add my own docs?") and it'll point you to the right one.
+
+| Command | What it does |
+| --- | --- |
+| `/graphrag build <path>` | Build a knowledge base from a file or folder of docs/code |
+| `/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 |
+| `/skills` | List your skills |
+| `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
+| `/<name>` | Run a skill |
+| `/loop <count> <prompt>` | Repeat a prompt N times (Esc stops) |
+| `/mcp` | List connected MCP servers + their tools |
+| `/model` · `/cwd` | Show/set model & endpoint · working directory |
+| `/undo` · `/back` | Revert the last write · rewind the last turn |
+| `/compact` · `/status` · `/clear` | Shrink context · session stats · reset |
+| `/help` · `/quit` | Help · exit |
+
+### Knowledge base (GraphRAG) — ingesting your documents
+
+```
+/graphrag build ./docs        # index a file or a whole folder
+/graphrag add ./more_docs     # add more later, incrementally
+/graphrag query "how are refunds handled?"   # check retrieval
+/graphrag status              # what's indexed
+```
+
+Once built, the agent **automatically** retrieves from it (read-only `Knowledge`
+tool) when a question touches your material. Ingests text formats
+(`.md .txt .py .js .json .yaml .sql …`); convert PDFs/Word to text first
+(e.g. `pdftotext file.pdf file.txt`). The index is a single JSON at
+`<project>/.drydock/graphrag.json` — clean-room, stdlib-only, no embeddings.
+
+### Custom skills
+
+```
+/skills new commitmsg  Write a concise conventional-commit message for: $ARGS
+/commitmsg the staged auth changes      # runs the skill with $ARGS substituted
+```
+
+Skills are markdown files in `~/.drydock/skills/` (personal) or
+`<project>/.drydock/skills/` (project); `/skills new` writes one for you.
+
 ## Install
 
 ```bash

{drydock_cli-3.0.59 → drydock_cli-3.0.61}/drydock_cli.egg-info/SOURCES.txt

@@ -65,6 +65,7 @@ tests/test_skills.py
 tests/test_stop.py
 tests/test_streaming_newlines.py
 tests/test_subagent.py
+tests/test_system_prompt_help.py
 tests/test_todo.py
 tests/test_tool_arg_parsing.py
 tests/test_tools_undo.py

{drydock_cli-3.0.59 → drydock_cli-3.0.61}/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.61"
 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.61}/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

{drydock_cli-3.0.59 → drydock_cli-3.0.61}/tests/test_skills.py

@@ -54,3 +54,28 @@ def test_empty_body_skipped(tmp_path):
 
 def test_no_skills_dir_is_empty(tmp_path):
     assert skills.load_skills(str(tmp_path)) == {}
+
+
+def test_create_skill_user_scope(tmp_path, monkeypatch):
+    monkeypatch.setattr(skills.Path, "home", lambda: tmp_path)
+    path = skills.create_skill("review", "Run GitDiff then review for bugs.",
+                               description="Review the diff")
+    assert path.exists()
+    loaded = skills.load_skills(str(tmp_path / "proj"))  # user-scope visible anywhere
+    assert "review" in loaded and "review for bugs" in loaded["review"].body
+    assert loaded["review"].description == "Review the diff"
+
+
+def test_create_skill_rejects_bad_name_and_empty_body(tmp_path, monkeypatch):
+    monkeypatch.setattr(skills.Path, "home", lambda: tmp_path)
+    import pytest
+    with pytest.raises(ValueError):
+        skills.create_skill("bad name!", "body")
+    with pytest.raises(ValueError):
+        skills.create_skill("ok", "   ")
+
+
+def test_create_skill_project_scope(tmp_path):
+    path = skills.create_skill("explain", "Explain $ARGS.", scope="project", cwd=str(tmp_path))
+    assert str(tmp_path) in str(path)
+    assert skills.load_skills(str(tmp_path))["explain"].render("auth.py") == "Explain auth.py."

drydock_cli-3.0.61/tests/test_system_prompt_help.py

@@ -0,0 +1,15 @@
+"""The system prompt must teach the model Drydock's own slash commands so it can
+answer 'how do I add documents / make a skill' when a user asks."""
+from __future__ import annotations
+
+from drydock.tuning import system_prompt_for_model
+
+
+def test_prompt_documents_graphrag_and_skills():
+    for model in ("gemma4", "some-other-model"):
+        p = system_prompt_for_model(model)
+        assert "/graphrag build" in p and "/graphrag add" in p
+        assert "/skills new" in p
+        assert "Knowledge" in p
+        # framed so the model explains, not runs, the command
+        assert "you do" in p.lower() and "not run" in p.lower()