drydock-cli 3.0.47__tar.gz → 3.0.49__tar.gz

{drydock_cli-3.0.47/drydock_cli.egg-info → drydock_cli-3.0.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.47
+Version: 3.0.49
 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.47 → drydock_cli-3.0.49}/drydock/agent.py

@@ -19,7 +19,7 @@ def _plan_has_unfinished(config: dict) -> bool:
     todo = config.get("_todo")
     return bool(todo) and any(status != "done" for _, status in todo)
 
-from drydock.providers import stream, AssistantTurn, TextChunk
+from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
 
@@ -168,7 +168,9 @@ def run(
                     tool_schemas=filter_tool_schemas(available, turn_config.get("model")),
                     config=turn_config,
                 ):
-                    if isinstance(event, TextChunk):
+                    if isinstance(event, ReasoningChunk):
+                        yield event
+                    elif isinstance(event, TextChunk):
                         yield event
                     elif isinstance(event, AssistantTurn):
                         assistant_turn = event

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/drydock/cli.py

@@ -149,7 +149,8 @@ def run_oneshot(prompt: str, config: dict) -> None:
 
 def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
     """Handle slash commands. Returns True if handled."""
-    cmd = cmd.lower().strip()
+    raw = cmd.strip()  # case-preserved (paths/args must not be lowercased)
+    cmd = raw.lower()
     if cmd == "/help":
         print_colored("Commands:", "bold")
         print("  /help     — show this help")
@@ -164,7 +165,7 @@ def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
         print_colored("  Conversation cleared.", "green")
         return True
     elif cmd == "/compact":
-        from drydock.compaction import compact, estimate_tokens
+        from drydock.compaction import compact, emergency_compact, estimate_tokens
 
         if not state.messages:
             print_colored("  Nothing to compact.", "dim")
@@ -172,6 +173,8 @@ def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
         before = estimate_tokens(state.messages)
         limit = config.get("context_limit", 65536) or 65536
         state.messages = compact(state.messages, limit)
+        if estimate_tokens(state.messages) > limit * 0.5:
+            state.messages = emergency_compact(state.messages, limit)
         after = estimate_tokens(state.messages)
         saved = before - after
         if saved > 0:
@@ -187,6 +190,37 @@ def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
         print_colored(f"  Messages: {len(state.messages)}", "cyan")
         print_colored(f"  Tokens: {state.total_input_tokens}in / {state.total_output_tokens}out", "cyan")
         return True
+    elif cmd.split()[0] == "/graphrag":
+        from drydock import graphrag
+
+        cwd = config.get("cwd") or os.getcwd()
+        store = graphrag.default_store_path(cwd)
+        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")
+            try:
+                stats = graphrag.build_index([rest], store, cwd=cwd)
+                print_colored(
+                    f"  ✓ {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")
+        elif sub == "clear":
+            store.unlink(missing_ok=True)
+            print_colored("  Knowledge base cleared.", "green")
+        else:
+            index = graphrag.load_index(store)
+            if index is None:
+                print_colored("  No knowledge base. Build: /graphrag build <path>", "dim")
+            else:
+                print_colored(
+                    f"  Knowledge base: {len(index.get('chunks', []))} chunks · "
+                    f"{len(index.get('entities', {}))} entities ({store})", "cyan")
+        return True
     elif cmd in ("/quit", "/exit"):
         raise KeyboardInterrupt
     return False
@@ -246,6 +280,11 @@ def main():
     parser.add_argument("--provider", help="Provider: vllm, ollama, lmstudio, openai")
     parser.add_argument("--base-url", dest="base_url", help="Override API base URL")
     parser.add_argument("--max-tokens", dest="max_tokens", type=int, help="Max response tokens")
+    parser.add_argument(
+        "--context-limit", dest="context_limit", type=int,
+        help="Model server context window (must match the server's -c / "
+             "--max-model-len; drives the ctx gauge + when compaction fires)",
+    )
     parser.add_argument("--temperature", type=float)
     parser.add_argument("--max-tool-calls", type=int, default=0, help="Max tool calls (0=unlimited)")
     parser.add_argument("--force-first-tool", action="store_true", help="Force tool_choice=required on first turn")
@@ -268,6 +307,7 @@ def main():
         "base_url": args.base_url,
         "max_tokens": args.max_tokens,
         "temperature": args.temperature,
+        "context_limit": args.context_limit,
     }, cfg_path)
 
     # First launch: ask the user for their model server URL + model name and
@@ -288,10 +328,11 @@ def main():
                 cfgmod.save_file(cfg, cfg_path)
 
     config = {
+        # context_limit now comes from cfg (DEFAULTS < config.toml < --context-limit)
+        # — it drives the ctx gauge AND when compaction fires, so it must match the
+        # server's real -c. Previously hardcoded to 65536 here, which clobbered the
+        # config value and overflowed servers running a smaller window.
         **cfg,
-        # Match the llama.cpp server's -c (gemma4 runs at 64k). Drives both the
-        # status-bar context gauge and when compaction kicks in.
-        "context_limit": 65536,
         "max_tool_calls": args.max_tool_calls,
         "force_first_tool": args.force_first_tool,
         "_approve_all": args.dangerously_skip_permissions,

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/drydock/config.py

@@ -28,6 +28,12 @@ DEFAULTS: dict[str, object] = {
     "base_url": "http://localhost:8000/v1",
     "max_tokens": 8192,  # 4096 truncated large file writes mid-JSON (→ _raw fail)
     "temperature": 0.2,
+    # The model server's context window (llama.cpp -c / vLLM --max-model-len).
+    # Drives the ctx gauge AND when compaction fires (it compacts at ~60% of
+    # this). It MUST match your server: if it's too high, drydock overflows the
+    # real window BEFORE compacting (the server 400s) — set this to your -c
+    # value. Default 65536 matches the bundled gemma4 server (-c 65536).
+    "context_limit": 65536,
     "theme": "harbor",
 }
 

drydock_cli-3.0.49/drydock/graphrag.py

@@ -0,0 +1,244 @@
+"""GraphRAG — a local, dependency-free knowledge graph for retrieval.
+
+The user builds an index from their own docs/code; the agent then queries it
+through the `Knowledge` tool while answering or coding, so it can ground its
+work in project-specific information the model was never trained on.
+
+Design (clean-room, stdlib only — no embeddings, no third-party deps, works
+against any server):
+  • Ingest text files → split into chunks.
+  • Extract ENTITIES from each chunk (proper nouns, `code` terms, CamelCase /
+    snake_case identifiers, ACRONYMS) → graph NODES.
+  • Entities co-occurring in a chunk get an EDGE (weighted by co-occurrence) →
+    the graph. Each entity also points at the chunks it appears in.
+  • Query: pull the query's entities + keywords, score chunks by entity and
+    keyword overlap, then EXPAND one hop along the entity graph so strongly
+    related context comes along — the "graph" in GraphRAG. Return the top
+    chunks plus the related entities, both fed back to the model.
+
+The index is a single JSON file so it's inspectable, portable, and gitignorable.
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+# Files we ingest as text. Everything else (binaries, images) is skipped.
+_TEXT_EXT = {
+    ".md", ".txt", ".rst", ".py", ".js", ".ts", ".tsx", ".jsx", ".java", ".go",
+    ".rs", ".c", ".h", ".cpp", ".hpp", ".cs", ".rb", ".php", ".sh", ".toml",
+    ".yaml", ".yml", ".json", ".cfg", ".ini", ".sql", ".html", ".css", ".org",
+    ".tex", ".csv", ".log", ".",
+}
+_SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist",
+              "build", ".mypy_cache", ".pytest_cache", ".drydock"}
+
+_STOPWORDS = frozenset("""
+the a an and or but if then else for while of to in on at by with from into as
+is are was were be been being do does did this that these those it its their
+your you we they he she his her our not no yes can will would should could may
+""".split())
+
+# Entity patterns (kept simple + fast; tuned to surface useful nodes, not noise)
+_RE_BACKTICK = re.compile(r"`([^`\n]{2,60})`")
+_RE_IDENT = re.compile(r"\b([a-zA-Z_][a-zA-Z0-9_]*(?:[_./][a-zA-Z0-9_]+)+)\b")
+_RE_CAMEL = re.compile(r"\b([A-Z][a-z0-9]+(?:[A-Z][a-z0-9]+)+)\b")
+_RE_PROPER = re.compile(r"\b([A-Z][a-zA-Z0-9]+(?:[ \t]+[A-Z][a-zA-Z0-9]+){0,3})\b")
+_RE_ACRONYM = re.compile(r"\b([A-Z]{2,6})\b")
+_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"
+
+
+def extract_entities(text: str) -> list[str]:
+    """Heuristic entity extraction → normalized (lowercased) entity keys."""
+    found: set[str] = set()
+    for rx in (_RE_BACKTICK, _RE_IDENT, _RE_CAMEL, _RE_PROPER, _RE_ACRONYM):
+        for m in rx.findall(text):
+            e = m.strip().lower()
+            # Drop trivial / stopword-only entities and overlong noise.
+            if len(e) < 3 or len(e) > 60:
+                continue
+            if all(w in _STOPWORDS for w in _RE_WORD.findall(e)):
+                continue
+            found.add(e)
+    return sorted(found)
+
+
+def _chunk_text(text: str, max_chars: int = 1200) -> list[str]:
+    """Split into paragraph-ish chunks, capping size so a chunk stays focused."""
+    chunks: list[str] = []
+    buf: list[str] = []
+    size = 0
+    for para in re.split(r"\n\s*\n", text):
+        para = para.strip()
+        if not para:
+            continue
+        if size + len(para) > max_chars and buf:
+            chunks.append("\n\n".join(buf))
+            buf, size = [], 0
+        if len(para) > max_chars:  # a single huge paragraph → hard-split
+            for i in range(0, len(para), max_chars):
+                chunks.append(para[i:i + max_chars])
+            continue
+        buf.append(para)
+        size += len(para)
+    if buf:
+        chunks.append("\n\n".join(buf))
+    return chunks
+
+
+def _iter_text_files(paths: list[str]):
+    for p in paths:
+        path = Path(p)
+        if path.is_file():
+            yield path
+        elif path.is_dir():
+            for root, dirs, files in os.walk(path):
+                dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
+                for f in files:
+                    fp = Path(root) / f
+                    if fp.suffix.lower() in _TEXT_EXT or fp.suffix == "":
+                        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
+
+    for fp in _iter_text_files([str(Path(cwd) / p) if not os.path.isabs(p) else p
+                                for p in paths]):
+        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)
+        for body in _chunk_text(text):
+            cid = len(chunks)
+            ents = extract_entities(body)
+            chunks.append({"id": cid, "source": rel, "text": body, "entities": ents})
+            for e in ents:
+                entity_chunks[e].add(cid)
+            for i, a in enumerate(ents):  # co-occurrence edges within the chunk
+                for b in ents[i + 1:]:
+                    edges[a][b] += 1
+                    edges[b][a] += 1
+
+    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,
+        "chunks": len(chunks),
+        "entities": len(entity_chunks),
+        "edges": sum(len(v) for v in edges.values()) // 2,
+    }
+
+
+def load_index(store_path: str | Path) -> dict | None:
+    sp = Path(store_path)
+    if not sp.exists():
+        return None
+    try:
+        return json.loads(sp.read_text("utf-8"))
+    except (OSError, ValueError):
+        return None
+
+
+def query_index(index: dict, query: str, *, k: int = 5, hops: bool = True) -> dict:
+    """Retrieve the top-k chunks for a query, expanded one hop over the graph.
+
+    Returns {chunks: [{source, text, score}], related: [entities]}.
+    """
+    chunks = index.get("chunks", [])
+    entities = index.get("entities", {})
+    edges = index.get("edges", {})
+    if not chunks:
+        return {"chunks": [], "related": []}
+
+    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}
+
+    # Match query entities to graph entities (exact + substring both ways).
+    matched: set[str] = set()
+    for qe in q_entities | q_words:
+        for ge in entities:
+            if qe == ge or qe in ge or ge in qe:
+                matched.add(ge)
+
+    # 1-hop graph expansion: pull the strongest neighbors of matched entities.
+    related: list[str] = []
+    expanded: set[str] = set(matched)
+    if hops:
+        for e in list(matched):
+            nbrs = sorted(edges.get(e, {}).items(), key=lambda kv: -kv[1])[:5]
+            for nbr, _w in nbrs:
+                expanded.add(nbr)
+                if nbr not in matched:
+                    related.append(nbr)
+
+    # Score chunks: direct entity hits weigh most, then graph-neighbor hits,
+    # then raw keyword overlap (so retrieval still works if entities miss).
+    scores: dict[int, float] = defaultdict(float)
+    for e in matched:
+        for cid in entities.get(e, []):
+            scores[cid] += 3.0
+    for e in expanded - matched:
+        for cid in entities.get(e, []):
+            scores[cid] += 1.0
+    for c in chunks:
+        if q_words:
+            overlap = len(q_words & {w.lower() for w in _RE_WORD.findall(c["text"])})
+            if overlap:
+                scores[c["id"]] += 0.5 * overlap
+
+    ranked = sorted(scores.items(), key=lambda kv: -kv[1])[:k]
+    out_chunks = [
+        {"source": chunks[cid]["source"], "text": chunks[cid]["text"], "score": round(sc, 1)}
+        for cid, sc in ranked if sc > 0
+    ]
+    # de-dup related, keep order, cap
+    seen: set[str] = set()
+    rel_unique = [r for r in related if not (r in seen or seen.add(r))][:12]
+    return {"chunks": out_chunks, "related": rel_unique}
+
+
+def format_results(result: dict, query: str) -> str:
+    """Render query results as the tool's string output for the model."""
+    chunks = result.get("chunks", [])
+    if not chunks:
+        return (
+            f"No knowledge-base matches for: {query!r}. The index may not cover "
+            "this topic — answer from your own knowledge, or ask the user to add "
+            "the relevant docs with /graphrag build <path>."
+        )
+    parts = [f"Knowledge base — {len(chunks)} relevant passage(s) for {query!r}:"]
+    for i, c in enumerate(chunks, 1):
+        parts.append(f"\n[{i}] (source: {c['source']}, score {c['score']})\n{c['text']}")
+    if result.get("related"):
+        parts.append("\nRelated entities in the graph: " + ", ".join(result["related"]))
+    return "\n".join(parts)

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/drydock/tools/__init__.py

@@ -161,6 +161,32 @@ SCHEMAS = [
             "required": ["prompt"],
         },
     },
+    {
+        "name": "Knowledge",
+        "description": (
+            "Search the user's KNOWLEDGE BASE (a GraphRAG index they built from "
+            "their own docs/code) for project-specific information you were not "
+            "trained on. Returns the most relevant passages plus related entities "
+            "from the graph. Use it BEFORE answering or coding when the task may "
+            "depend on the user's private/project knowledge (their APIs, specs, "
+            "data, conventions). If it returns no matches, the topic isn't in the "
+            "base — answer normally."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "What to look up, as a natural-language question or keywords.",
+                },
+                "k": {
+                    "type": "integer",
+                    "description": "Max passages to return (default 5).",
+                },
+            },
+            "required": ["query"],
+        },
+    },
 ]
 
 # ── Tool implementations ──────────────────────────────────────────────────
@@ -709,6 +735,32 @@ def tool_task(params: dict, config: dict) -> str:
     return f"[sub-agent finished {steps} step(s) with no summary]"
 
 
+def tool_knowledge(params: dict, config: dict) -> str:
+    """Query the project's GraphRAG knowledge base (built with /graphrag build).
+    Read-only; returns the most relevant passages plus related graph entities.
+    If no index exists, says so cleanly rather than erroring."""
+    from drydock import graphrag
+
+    query = (params.get("query") or "").strip()
+    if not query:
+        return "Error: `Knowledge` needs a `query` describing what to look up."
+    cwd = config.get("cwd") or os.getcwd()
+    store = config.get("graphrag_store") or graphrag.default_store_path(cwd)
+    index = graphrag.load_index(store)
+    if index is None:
+        return (
+            "No knowledge base has been built yet. The user can build one with "
+            "'/graphrag build <path>' (a file or directory of docs/code). Until "
+            "then, answer from your own knowledge."
+        )
+    try:
+        k = int(params.get("k") or 5)
+    except (TypeError, ValueError):
+        k = 5
+    result = graphrag.query_index(index, query, k=max(1, min(k, 15)))
+    return graphrag.format_results(result, query)
+
+
 # ── Register all tools ────────────────────────────────────────────────────
 
 _TOOLS = [
@@ -720,6 +772,7 @@ _TOOLS = [
     ("Grep", tool_grep, True),
     ("todo", tool_todo, False),
     ("task", tool_task, True),
+    ("Knowledge", tool_knowledge, True),
 ]
 
 def register_all():
@@ -728,10 +781,10 @@ def register_all():
         func = {
             "Read": tool_read, "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
-            "todo": tool_todo, "task": tool_task,
+            "todo": tool_todo, "task": tool_task, "Knowledge": tool_knowledge,
         }[name]
-        # `task` is read-only w.r.t. the parent's files (it can't Write/Edit).
-        read_only = name in ("Read", "Glob", "Grep", "task")
+        # task + Knowledge are read-only w.r.t. the parent's files.
+        read_only = name in ("Read", "Glob", "Grep", "task", "Knowledge")
         register(ToolDef(name=name, schema=schema, func=func, read_only=read_only))
 
 register_all()

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/drydock/tui/app.py

@@ -19,6 +19,7 @@ from textual.widgets import Static
 
 from drydock.agent import (
     AgentState,
+    ReasoningChunk,
     TextChunk,
     ToolEnd,
     ToolStart,
@@ -28,6 +29,7 @@ from drydock.agent import (
 from drydock.tui.messages import (
     AgentError,
     AgentFinished,
+    AgentReasoning,
     AgentText,
     AgentToolEnd,
     AgentToolStart,
@@ -38,6 +40,7 @@ from drydock.tui.widgets import (
     AssistantMessage,
     ErrorMessage,
     PromptArea,
+    ReasoningCard,
     ToolCard,
     UserMessage,
     result_is_ok,
@@ -92,6 +95,10 @@ class DrydockApp(App):
     .tool-card.ok { border-left: thick #2e8b6b; }
     .tool-card.fail { border-left: thick #b3503e; }
     .tool-body { color: #9bb4c0; padding: 0 1; }
+    .reasoning-card {
+        margin: 0 0 0 2; border-left: thick #6a5acd; background: #14132a;
+    }
+    .reasoning-body { color: #9a93c0; padding: 0 1; }
     /* Pinned task checklist in the footer (height auto → 0 lines when empty). */
     #todo {
         height: auto; margin: 0 2 1 2; padding: 0 1; color: #d7e6ee;
@@ -455,6 +462,8 @@ class DrydockApp(App):
                 self._info("Nothing to go back to.")
         elif cmd == "/compact":
             self._cmd_compact()
+        elif cmd == "/graphrag":
+            self._cmd_graphrag(arg)
         elif cmd == "/status":
             t = self.state
             self._info(
@@ -474,6 +483,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"
                 "  /clear           reset the conversation\n"
                 "  /quit            exit\n"
                 "Type a task and press Enter. ↑/↓ recall history · Esc stops · Ctrl+O expands tools."
@@ -485,8 +496,11 @@ class DrydockApp(App):
         """Manually compact the conversation to reclaim context NOW, without
         waiting for the automatic 60%-of-window threshold (agent.maybe_compact).
         Truncates/drops old tool results and oversized tool-call arguments while
-        keeping recent turns intact (see compaction.compact)."""
-        from drydock.compaction import compact, estimate_tokens
+        keeping recent turns intact (see compaction.compact). If a normal pass
+        can't free enough (history dominated by big messages, not tool output),
+        it ESCALATES to emergency_compact so an explicit /compact always helps —
+        the user asked to free space, so being aggressive is the right call."""
+        from drydock.compaction import compact, emergency_compact, estimate_tokens
 
         msgs = self.state.messages
         if not msgs:
@@ -495,6 +509,11 @@ class DrydockApp(App):
         before = estimate_tokens(msgs)
         limit = self.config.get("context_limit", 65536) or 65536
         self.state.messages = compact(msgs, limit)
+        # Escalate when the normal pass left us still heavy (>50% of the window):
+        # this is exactly the "tried /compact, it said nothing, then OOM again"
+        # case — the bloat isn't in droppable tool results, so go aggressive.
+        if estimate_tokens(self.state.messages) > limit * 0.5:
+            self.state.messages = emergency_compact(self.state.messages, limit)
         after = estimate_tokens(self.state.messages)
         saved = before - after
         if saved > 0:
@@ -517,6 +536,54 @@ class DrydockApp(App):
                 "(recent turns are always preserved)."
             )
 
+    def _cmd_graphrag(self, arg: str) -> None:
+        """Build / inspect / clear the project's GraphRAG knowledge base. Once
+        built, the agent retrieves from it via the read-only Knowledge tool."""
+        from drydock import graphrag
+
+        cwd = self.config.get("cwd") or "."
+        store = graphrag.default_store_path(cwd)
+        parts = arg.split(maxsplit=1)
+        sub = parts[0].lower() if parts else ""
+        rest = parts[1].strip() if len(parts) > 1 else ""
+
+        if sub == "build":
+            if not rest:
+                self._info("usage: /graphrag build <path>   (a file or directory of docs/code)")
+                return
+            self._info(f"Building knowledge base from {rest} …")
+            try:
+                stats = graphrag.build_index([rest], store, cwd=cwd)
+            except Exception as e:  # noqa: BLE001 — surface, never crash the TUI
+                self._mount(ErrorMessage(f"graphrag build failed: {e}"))
+                return
+            if not stats["chunks"]:
+                self._info(f"No text found under {rest}. Nothing was indexed.")
+                return
+            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."
+            )
+        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:
+                self._info(
+                    f"Knowledge base: {len(index.get('chunks', []))} chunks · "
+                    f"{len(index.get('entities', {}))} entities  ({store})."
+                )
+        elif sub == "clear":
+            try:
+                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>  ·  /graphrag status  ·  /graphrag clear")
+
     def _persist_config(self) -> None:
         """Save the persistable settings (model/provider/base_url/… — save_file
         filters to those) to ~/.drydock/config.toml so setup survives restart."""
@@ -600,7 +667,9 @@ class DrydockApp(App):
     def _run_agent(self, text: str) -> None:
         try:
             for ev in run(text, self.state, self.config, self.system):
-                if isinstance(ev, TextChunk):
+                if isinstance(ev, ReasoningChunk):
+                    self.post_message(AgentReasoning(ev.text))
+                elif isinstance(ev, TextChunk):
                     self.post_message(AgentText(ev.text))
                 elif isinstance(ev, ToolStart):
                     self.post_message(AgentToolStart(ev.name, ev.inputs))
@@ -615,6 +684,14 @@ class DrydockApp(App):
 
     # ── agent → UI handlers ───────────────────────────────────────────────
 
+    def on_agent_reasoning(self, m: AgentReasoning) -> None:
+        # The model's thinking for this turn, rendered as a collapsed card BEFORE
+        # the answer text (reasoning is yielded before TextChunk). End any current
+        # text block so the answer starts fresh below the card.
+        self._current_assistant = None
+        self._mount(ReasoningCard(m.text))
+        self._scroll.scroll_end(animate=False)
+
     def on_agent_text(self, m: AgentText) -> None:
         self._ensure_assistant().append(m.text)
         self._work_chars += len(m.text)

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/drydock/tui/messages.py

@@ -9,6 +9,12 @@ from __future__ import annotations
 from textual.message import Message
 
 
+class AgentReasoning(Message):
+    def __init__(self, text: str) -> None:
+        self.text = text
+        super().__init__()
+
+
 class AgentText(Message):
     def __init__(self, text: str) -> None:
         self.text = text

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/drydock/tui/widgets.py

@@ -153,7 +153,7 @@ class PromptHistory:
 # completes the prefix.
 SLASH_COMMANDS = [
     "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/clear", "/quit",
+    "/compact", "/graphrag", "/clear", "/quit",
 ]
 
 
@@ -266,6 +266,29 @@ class ErrorMessage(Static):
         super().__init__(f"⚠ {text}", classes="error-msg", markup=False)
 
 
+class ReasoningCard(Collapsible):
+    """The model's thinking for a turn — collapsed by default so a long reasoning
+    block (gemma runs a 20k-token budget) doesn't flood the transcript; expand
+    to read it. Distinct from the answer, which renders as an AssistantMessage."""
+
+    def __init__(self, text: str) -> None:
+        self._buf = text
+        self._body = Static(text, classes="reasoning-body", markup=False)
+        n = len(text)
+        super().__init__(
+            self._body,
+            title=f"💭 thinking  ·  {n:,} chars",
+            collapsed=True,
+        )
+        self.add_class("reasoning-card")
+
+    def append(self, text: str) -> None:
+        """Grow the block if a turn streams reasoning in multiple chunks."""
+        self._buf += text
+        self._body.update(self._buf)
+        self.title = f"💭 thinking  ·  {len(self._buf):,} chars"
+
+
 class ToolCard(Collapsible):
     """A tool call: compact header (name + summary), expandable full output."""
 

{drydock_cli-3.0.47 → drydock_cli-3.0.49/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.47
+Version: 3.0.49
 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.47 → drydock_cli-3.0.49}/drydock_cli.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ drydock/cli.py
 drydock/compaction.py
 drydock/config.py
 drydock/detect.py
+drydock/graphrag.py
 drydock/guards.py
 drydock/loop_detect.py
 drydock/providers.py
@@ -37,10 +38,12 @@ tests/test_compact_command.py
 tests/test_compaction.py
 tests/test_config.py
 tests/test_config_migration.py
+tests/test_context_limit_config.py
 tests/test_detect.py
 tests/test_empty_response.py
 tests/test_failure_loop.py
 tests/test_first_run_setup.py
+tests/test_graphrag.py
 tests/test_guards_and_tools.py
 tests/test_hallucinated_tools.py
 tests/test_leaked_tool_call.py

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

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/tests/test_config.py

@@ -84,5 +84,8 @@ def test_save_drops_runtime_only_keys(tmp_path):
     cfg.save_file({"model": "g", "cwd": "/tmp", "context_limit": 999}, path)
     with path.open("rb") as f:
         written = tomllib.load(f)
-    assert "cwd" not in written and "context_limit" not in written
+    # cwd is runtime-only (dropped); context_limit is a real persistent setting
+    # (users must be able to match it to their server's window).
+    assert "cwd" not in written
+    assert written["context_limit"] == 999
     assert written["model"] == "g"

drydock_cli-3.0.49/tests/test_context_limit_config.py

@@ -0,0 +1,44 @@
+"""context_limit must be a config.toml setting (not hardcoded), so users whose
+model server runs a smaller window can lower it — otherwise drydock overflows
+the real context before compaction fires. Reported from real use: OOM at 32k
+while the hardcoded limit was 65536, and /compact found 'nothing to compact'."""
+from __future__ import annotations
+
+from drydock import config as cfgmod
+from drydock.agent import AgentState
+from drydock.compaction import estimate_tokens
+from drydock import cli
+
+
+def test_context_limit_is_a_default_and_written_to_file(tmp_path):
+    path = tmp_path / "config.toml"
+    cfg = cfgmod.resolve({}, path)
+    assert "context_limit" in cfg                      # present in resolved config
+    assert "context_limit" in path.read_text()         # persisted to the file
+
+
+def test_config_file_value_is_respected(tmp_path):
+    path = tmp_path / "config.toml"
+    path.write_text('model = "gemma4"\ncontext_limit = 32768\n')
+    cfg = cfgmod.resolve({}, path)
+    assert cfg["context_limit"] == 32768
+
+
+def test_cli_flag_overrides_file(tmp_path):
+    path = tmp_path / "config.toml"
+    path.write_text('context_limit = 32768\n')
+    cfg = cfgmod.resolve({"context_limit": 16384}, path)
+    assert cfg["context_limit"] == 16384
+
+
+def test_compact_escalates_when_bloat_is_not_tool_results(capsys):
+    # History dominated by big ASSISTANT text — normal compact() barely helps,
+    # so an explicit /compact must escalate (emergency_compact) and free space.
+    state = AgentState()
+    state.messages = [{"role": "user", "content": "start"}]
+    for i in range(8):
+        state.messages.append({"role": "assistant", "content": f"answer {i} " + "x" * 4000})
+    before = estimate_tokens(state.messages)
+    cli.handle_command("/compact", state, {"context_limit": 16384})
+    after = estimate_tokens(state.messages)
+    assert after < before * 0.7      # escalation actually reclaimed space

drydock_cli-3.0.49/tests/test_graphrag.py

@@ -0,0 +1,75 @@
+"""GraphRAG: a local, dependency-free knowledge graph the user builds and the
+agent queries via the read-only Knowledge tool."""
+from __future__ import annotations
+
+from drydock import graphrag
+from drydock.tools import tool_knowledge
+
+
+def _corpus(tmp_path):
+    d = tmp_path / "docs"
+    d.mkdir()
+    (d / "payments.md").write_text(
+        "The Acme Payments Service authorizes a charge via the Zephyr-Key header "
+        "for idempotency. Webhooks are signed with WEBHOOK_SECRET using HMAC-SHA256."
+    )
+    (d / "inventory.md").write_text(
+        "The InventoryManager fires low-stock alerts when quantity drops below "
+        "the reorder_threshold. The nightly ReorderJob emails procurement."
+    )
+    return d
+
+
+def test_build_and_query_routes_to_right_doc(tmp_path):
+    store = tmp_path / ".drydock" / "graphrag.json"
+    stats = graphrag.build_index(["docs"], store, cwd=str(tmp_path))
+    assert stats["files"] == 2 and stats["chunks"] >= 2 and stats["entities"] > 0
+
+    idx = graphrag.load_index(store)
+    pay = graphrag.query_index(idx, "how do I authorize a charge with idempotency?")
+    assert pay["chunks"] and pay["chunks"][0]["source"].endswith("payments.md")
+
+    inv = graphrag.query_index(idx, "low stock alerts and reorder threshold")
+    assert inv["chunks"] and inv["chunks"][0]["source"].endswith("inventory.md")
+
+
+def test_entities_do_not_span_newlines(tmp_path):
+    store = tmp_path / ".drydock" / "graphrag.json"
+    graphrag.build_index(["docs"], store, cwd=str(tmp_path))
+    idx = graphrag.load_index(store)
+    assert all("\n" not in e for e in idx["entities"])  # proper nouns stay on one line
+
+
+def test_graph_expansion_returns_related_entities(tmp_path):
+    store = tmp_path / ".drydock" / "graphrag.json"
+    graphrag.build_index(["docs"], store, cwd=str(tmp_path))
+    idx = graphrag.load_index(store)
+    res = graphrag.query_index(idx, "ReorderJob")
+    # 1-hop expansion should pull co-occurring entities from the same chunk.
+    assert any("reorder_threshold" in r or "inventorymanager" in r for r in res["related"])
+
+
+def test_knowledge_tool_without_index_is_graceful(tmp_path):
+    out = tool_knowledge({"query": "anything"}, {"cwd": str(tmp_path)})
+    assert "No knowledge base" in out and "graphrag build" in out
+
+
+def test_knowledge_tool_returns_passages(tmp_path):
+    store = graphrag.default_store_path(str(tmp_path))
+    graphrag.build_index(["docs"], store, cwd=str(tmp_path))
+    out = tool_knowledge({"query": "authorize a charge", "k": 2}, {"cwd": str(tmp_path)})
+    assert "payments.md" in out and "Zephyr-Key" in out
+
+
+def test_knowledge_tool_needs_a_query(tmp_path):
+    assert "needs a `query`" in tool_knowledge({}, {"cwd": str(tmp_path)})
+
+
+# Make the corpus available to every test via an autouse fixture.
+import pytest  # noqa: E402
+
+
+@pytest.fixture(autouse=True)
+def _make_corpus(tmp_path):
+    _corpus(tmp_path)
+    yield

{drydock_cli-3.0.47 → drydock_cli-3.0.49}/tests/test_tuning.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from drydock.tuning import (
     GEMMA_DISABLED_TOOLS,
+    extract_thinking,
     filter_tool_schemas,
     is_gemma,
     strip_thinking_tokens,
@@ -96,3 +97,56 @@ def test_thinking_level_adaptive():
     assert thinking_level_for_turn(1, is_user_turn=False) == "high"
     assert thinking_level_for_turn(5, is_user_turn=False) == "off"
     assert thinking_level_for_turn(5, is_user_turn=True) == "high"
+
+
+# --- extract_thinking ---
+
+def test_extract_thinking_no_block():
+    thinking, text = extract_thinking("hello world")
+    assert thinking == ""
+    assert text == "hello world"
+
+
+def test_extract_thinking_empty_string():
+    thinking, text = extract_thinking("")
+    assert thinking == ""
+    assert text == ""
+
+
+def test_extract_thinking_extracts_and_strips():
+    raw = "<|channel>my thought<channel|>the answer"
+    thinking, text = extract_thinking(raw)
+    assert thinking == "my thought"
+    assert text == "the answer"
+
+
+def test_extract_thinking_multiline_block():
+    raw = "<|channel>line1\nline2<channel|>result"
+    thinking, text = extract_thinking(raw)
+    assert thinking == "line1\nline2"
+    assert text == "result"
+
+
+def test_extract_thinking_tool_call_closer():
+    # Thought running into a malformed tool call closes with <tool_call|>.
+    raw = "<|channel>secret thought<tool_call|>visible"
+    thinking, text = extract_thinking(raw)
+    assert thinking == "secret thought"
+    assert text == "visible"
+
+
+def test_extract_thinking_multiple_blocks():
+    raw = "<|channel>thought1<channel|>text1<|channel>thought2<channel|>text2"
+    thinking, text = extract_thinking(raw)
+    assert "thought1" in thinking
+    assert "thought2" in thinking
+    assert "text1" in text
+    assert "text2" in text
+    assert "<|channel>" not in text
+
+
+def test_extract_thinking_noop_when_no_marker():
+    raw = "no markers here <b>html</b>"
+    thinking, text = extract_thinking(raw)
+    assert thinking == ""
+    assert text == raw