drydock-cli 3.0.50__tar.gz → 3.0.52__tar.gz

{drydock_cli-3.0.50/drydock_cli.egg-info → drydock_cli-3.0.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.50
+Version: 3.0.52
 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.52/drydock/gittools.py

@@ -0,0 +1,96 @@
+"""Dedicated Version Control helpers — first-class git for the agent.
+
+Git works through the generic Bash tool, but purpose-built git_* tools give the
+model concise, structured, TRUNCATED output (a raw `git diff` can blow the
+context window) and a safe commit path, without it having to remember exact git
+invocations. Read ops (status/diff/log) are side-effect-free; commit is local
+and reversible (push stays gated through Bash's approval modal).
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import subprocess
+
+
+class GitError(RuntimeError):
+    """A git operation failed (not a repo, git missing, or a command error)."""
+
+
+def _run_git(args: list[str], cwd: str, timeout: float = 30.0) -> str:
+    """Run `git <args>` in cwd, returning stdout. Raises GitError on failure."""
+    try:
+        p = subprocess.run(
+            ["git", *args], cwd=cwd, capture_output=True, text=True,
+            timeout=timeout,
+        )
+    except FileNotFoundError as e:
+        raise GitError("git is not installed or not on PATH") from e
+    except subprocess.TimeoutExpired as e:
+        raise GitError(f"git {args[0]} timed out after {timeout:.0f}s") from e
+    if p.returncode != 0:
+        err = (p.stderr or p.stdout or "").strip()
+        if "not a git repository" in err.lower():
+            raise GitError(f"not a git repository: {cwd}")
+        raise GitError(err or f"git {args[0]} failed (exit {p.returncode})")
+    return p.stdout
+
+
+def _truncate(text: str, max_chars: int, *, tail: bool = False) -> str:
+    if len(text) <= max_chars:
+        return text
+    note = f"\n[... {len(text) - max_chars} chars truncated ...]\n"
+    return (note + text[-max_chars:]) if tail else (text[:max_chars] + note)
+
+
+def status(cwd: str) -> str:
+    """Branch + concise porcelain status of the working tree."""
+    branch = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd).strip()
+    porcelain = _run_git(["status", "--porcelain=v1", "--branch"], cwd).strip()
+    if len(porcelain.splitlines()) <= 1:  # only the "## branch" header line
+        return f"On branch {branch}. Working tree clean."
+    return f"On branch {branch}:\n{_truncate(porcelain, 4000)}"
+
+
+def diff(cwd: str, path: str | None = None, *, staged: bool = False,
+         max_chars: int = 8000) -> str:
+    """Working-tree (or --staged) diff, optionally scoped to a path. Truncated."""
+    args = ["diff"]
+    if staged:
+        args.append("--cached")
+    if path:
+        args += ["--", path]
+    out = _run_git(args, cwd)
+    if not out.strip():
+        scope = " (staged)" if staged else ""
+        return f"No{scope} changes" + (f" in {path}" if path else "") + "."
+    # Lead with a --stat summary so the model sees the shape even when truncated.
+    stat_args = ["diff", "--stat"] + (["--cached"] if staged else [])
+    if path:
+        stat_args += ["--", path]
+    stat = _run_git(stat_args, cwd).strip()
+    return f"{stat}\n\n{_truncate(out, max_chars)}"
+
+
+def log(cwd: str, n: int = 10) -> str:
+    """The last n commits, one line each."""
+    n = max(1, min(n, 50))
+    out = _run_git(["log", f"-{n}", "--oneline", "--decorate"], cwd).strip()
+    return out or "No commits yet."
+
+
+def commit(cwd: str, message: str, *, add_all: bool = True) -> str:
+    """Stage (all, by default) and commit. Local + reversible (git reset undoes
+    it). Refuses an empty message. Does NOT push."""
+    message = (message or "").strip()
+    if not message:
+        raise GitError("a commit needs a non-empty message")
+    if add_all:
+        _run_git(["add", "-A"], cwd)
+    # Nothing staged → say so instead of erroring opaquely.
+    staged = _run_git(["diff", "--cached", "--name-only"], cwd).strip()
+    if not staged:
+        return "Nothing to commit — the working tree has no staged changes."
+    out = _run_git(["commit", "-m", message], cwd)
+    head = _run_git(["rev-parse", "--short", "HEAD"], cwd).strip()
+    return f"Committed {head}:\n{out.strip()}"

drydock_cli-3.0.52/drydock/skills.py

@@ -0,0 +1,90 @@
+"""Skills — user-defined reusable slash commands.
+
+A skill is a markdown file with simple frontmatter; its body is a prompt the
+user invokes as ``/<name>`` in the TUI (or --cli). It saves retyping common
+instructions ("/review", "/explain", "/testgen") and ships project conventions
+alongside the code.
+
+Discovery (project overrides user on a name clash):
+  • ~/.drydock/skills/*.md          (personal, all projects)
+  • <cwd>/.drydock/skills/*.md      (this project)
+
+File format (frontmatter optional; name defaults to the filename):
+    ---
+    name: review
+    description: Review the current diff for bugs
+    ---
+    Run GitDiff, then review the changes for bugs and suggest fixes.
+
+Invocation:
+  • ``/review``                 → the body becomes the user turn.
+  • ``/review focus on perf``   → trailing text replaces ``$ARGS`` in the body,
+    or is appended if the body has no ``$ARGS`` placeholder.
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+_FRONTMATTER = re.compile(r"^---\n(.*?)\n---\n?(.*)$", re.S)
+_NAME_RE = re.compile(r"^[a-z0-9][a-z0-9_-]*$", re.I)
+
+
+@dataclass
+class Skill:
+    name: str
+    description: str
+    body: str
+    source: str  # file path, for /skills listing
+
+    def render(self, args: str = "") -> str:
+        """Expand the skill into a prompt, substituting/append args."""
+        args = (args or "").strip()
+        if "$ARGS" in self.body:
+            return self.body.replace("$ARGS", args)
+        return f"{self.body}\n\n{args}".rstrip() if args else self.body
+
+
+def _parse(path: Path) -> Skill | None:
+    try:
+        text = path.read_text("utf-8", "ignore")
+    except OSError:
+        return None
+    name = path.stem.lower()
+    description = ""
+    body = text
+    m = _FRONTMATTER.match(text)
+    if m:
+        meta, body = m.group(1), m.group(2)
+        for line in meta.splitlines():
+            if ":" in line:
+                key, _, val = line.partition(":")
+                key, val = key.strip().lower(), val.strip()
+                if key == "name" and val:
+                    name = val.lower()
+                elif key == "description":
+                    description = val
+    body = body.strip()
+    if not body or not _NAME_RE.match(name):
+        return None
+    return Skill(name=name, description=description, body=body, source=str(path))
+
+
+def skills_dirs(cwd: str) -> list[Path]:
+    return [Path.home() / ".drydock" / "skills", Path(cwd) / ".drydock" / "skills"]
+
+
+def load_skills(cwd: str) -> dict[str, Skill]:
+    """Load all skills; later dirs (project) override earlier (user) by name."""
+    skills: dict[str, Skill] = {}
+    for d in skills_dirs(cwd):
+        if not d.is_dir():
+            continue
+        for f in sorted(d.glob("*.md")):
+            sk = _parse(f)
+            if sk:
+                skills[sk.name] = sk
+    return skills

{drydock_cli-3.0.50 → drydock_cli-3.0.52}/drydock/tools/__init__.py

@@ -161,6 +161,56 @@ SCHEMAS = [
             "required": ["prompt"],
         },
     },
+    {
+        "name": "GitStatus",
+        "description": (
+            "Show the current branch and a concise list of changed/staged/"
+            "untracked files (git status). Use it to understand the working tree "
+            "before editing or committing."
+        ),
+        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "GitDiff",
+        "description": (
+            "Show the diff of changes (git diff), with a --stat summary first and "
+            "the body truncated to fit context. Set staged=true for staged "
+            "changes; pass a path to scope it to one file/dir."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "Optional file/dir to scope the diff."},
+                "staged": {"type": "boolean", "description": "Diff staged changes instead of the working tree."},
+            },
+        },
+    },
+    {
+        "name": "GitLog",
+        "description": "Show the last n commits, one line each (git log --oneline).",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "n": {"type": "integer", "description": "How many commits (default 10)."},
+            },
+        },
+    },
+    {
+        "name": "GitCommit",
+        "description": (
+            "Stage all changes and commit with a message (git add -A && git "
+            "commit). Local and reversible; does NOT push. Use it to package a "
+            "completed, verified change. Write a clear, specific message."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string", "description": "The commit message."},
+                "add_all": {"type": "boolean", "description": "Stage all changes first (default true)."},
+            },
+            "required": ["message"],
+        },
+    },
     {
         "name": "WebSearch",
         "description": (
@@ -769,6 +819,54 @@ def tool_task(params: dict, config: dict) -> str:
     return f"[sub-agent finished {steps} step(s) with no summary]"
 
 
+def _git_cwd(config: dict) -> str:
+    return config.get("cwd") or os.getcwd()
+
+
+def tool_gitstatus(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        return gittools.status(_git_cwd(config))
+    except gittools.GitError as e:
+        return f"git status failed: {e}"
+
+
+def tool_gitdiff(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        return gittools.diff(
+            _git_cwd(config),
+            path=(params.get("path") or None),
+            staged=bool(params.get("staged")),
+        )
+    except gittools.GitError as e:
+        return f"git diff failed: {e}"
+
+
+def tool_gitlog(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        n = int(params.get("n") or 10)
+    except (TypeError, ValueError):
+        n = 10
+    try:
+        return gittools.log(_git_cwd(config), n=n)
+    except gittools.GitError as e:
+        return f"git log failed: {e}"
+
+
+def tool_gitcommit(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        return gittools.commit(
+            _git_cwd(config),
+            params.get("message") or "",
+            add_all=params.get("add_all", True) is not False,
+        )
+    except gittools.GitError as e:
+        return f"git commit failed: {e}"
+
+
 def tool_websearch(params: dict, config: dict) -> str:
     """Search the internet (DuckDuckGo). Read-only; clean message when offline."""
     from drydock import web
@@ -845,6 +943,10 @@ _TOOLS = [
     ("Knowledge", tool_knowledge, True),
     ("WebSearch", tool_websearch, True),
     ("WebFetch", tool_webfetch, True),
+    ("GitStatus", tool_gitstatus, True),
+    ("GitDiff", tool_gitdiff, True),
+    ("GitLog", tool_gitlog, True),
+    ("GitCommit", tool_gitcommit, False),
 ]
 
 def register_all():
@@ -855,10 +957,14 @@ def register_all():
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
             "todo": tool_todo, "task": tool_task, "Knowledge": tool_knowledge,
             "WebSearch": tool_websearch, "WebFetch": tool_webfetch,
+            "GitStatus": tool_gitstatus, "GitDiff": tool_gitdiff,
+            "GitLog": tool_gitlog, "GitCommit": tool_gitcommit,
         }[name]
-        # These are read-only w.r.t. the parent's files.
+        # Read-only w.r.t. the parent's files (GitStatus/Diff/Log inspect only;
+        # GitCommit writes a local, reversible commit).
         read_only = name in (
             "Read", "Glob", "Grep", "task", "Knowledge", "WebSearch", "WebFetch",
+            "GitStatus", "GitDiff", "GitLog",
         )
         register(ToolDef(name=name, schema=schema, func=func, read_only=read_only))
 

{drydock_cli-3.0.50 → drydock_cli-3.0.52}/drydock/tui/app.py

@@ -236,6 +236,8 @@ class DrydockApp(App):
         self.config = config
         self.state = AgentState()
         self.system = self._build_system(config.get("model"))
+        from drydock.skills import load_skills
+        self._skills = load_skills(config.get("cwd") or ".")
         self._current_assistant: AssistantMessage | None = None
         self._last_card: ToolCard | None = None
         self._busy = False
@@ -375,7 +377,8 @@ class DrydockApp(App):
             return
         hint = ""
         if text.startswith("/") and " " not in text and "\n" not in text:
-            matches = [c for c in SLASH_COMMANDS if c.startswith(text.lower())]
+            commands = SLASH_COMMANDS + ["/skills"] + [f"/{n}" for n in sorted(self._skills)]
+            matches = [c for c in commands if c.startswith(text.lower())]
             if matches:
                 hint = "  " + "   ".join(matches) + "   ·  Tab to complete"
         self.query_one("#working", Static).update(hint)
@@ -485,13 +488,43 @@ class DrydockApp(App):
                 "  /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"
                 "  /clear           reset the conversation\n"
                 "  /quit            exit\n"
                 "Type a task and press Enter. ↑/↓ recall history · Esc stops · Ctrl+O expands tools."
             )
+        elif cmd == "/skills":
+            self._cmd_skills()
+        elif cmd[1:] in self._skills:
+            self._run_skill(self._skills[cmd[1:]], arg)
         else:
             self._mount(ErrorMessage(f"unknown command: {cmd} (try /help)"))
 
+    def _cmd_skills(self) -> None:
+        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."
+            )
+            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 ""))
+        self._info("\n".join(lines))
+
+    def _run_skill(self, skill, arg: str) -> None:
+        """Expand a skill into a prompt and run it as a normal user turn."""
+        prompt = skill.render(arg)
+        self._mount(UserMessage(f"/{skill.name}" + (f" {arg}" if arg else "")))
+        if self._busy:
+            self._queue.append(prompt)
+            self._refresh_status()
+        else:
+            self._begin(prompt)
+
     def _cmd_compact(self) -> None:
         """Manually compact the conversation to reclaim context NOW, without
         waiting for the automatic 60%-of-window threshold (agent.maybe_compact).

{drydock_cli-3.0.50 → drydock_cli-3.0.52/drydock_cli.egg-info}/PKG-INFO

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

@@ -10,10 +10,12 @@ drydock/cli.py
 drydock/compaction.py
 drydock/config.py
 drydock/detect.py
+drydock/gittools.py
 drydock/graphrag.py
 drydock/guards.py
 drydock/loop_detect.py
 drydock/providers.py
+drydock/skills.py
 drydock/tool_registry.py
 drydock/tuning.py
 drydock/web.py
@@ -44,6 +46,7 @@ tests/test_detect.py
 tests/test_empty_response.py
 tests/test_failure_loop.py
 tests/test_first_run_setup.py
+tests/test_gittools.py
 tests/test_graphrag.py
 tests/test_guards_and_tools.py
 tests/test_hallucinated_tools.py
@@ -53,6 +56,7 @@ tests/test_oneshot_unreachable.py
 tests/test_plan_autocontinue.py
 tests/test_providers_unreachable.py
 tests/test_runaway_repetition.py
+tests/test_skills.py
 tests/test_stop.py
 tests/test_streaming_newlines.py
 tests/test_subagent.py

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

drydock_cli-3.0.52/tests/test_gittools.py

@@ -0,0 +1,78 @@
+"""Dedicated Version Control tools (drydock/gittools.py): structured, truncated
+git for the agent. Tests run in isolated temp repos."""
+from __future__ import annotations
+
+import subprocess
+
+import pytest
+
+from drydock import gittools
+from drydock.tools import (
+    tool_gitstatus, tool_gitdiff, tool_gitlog, tool_gitcommit,
+)
+
+
+def _git(args, cwd):
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True, text=True)
+
+
+@pytest.fixture
+def repo(tmp_path):
+    _git(["init", "-q"], tmp_path)
+    _git(["config", "user.email", "t@t.com"], tmp_path)
+    _git(["config", "user.name", "T"], tmp_path)
+    (tmp_path / "a.txt").write_text("hello\n")
+    _git(["add", "-A"], tmp_path)
+    _git(["commit", "-qm", "initial"], tmp_path)
+    return tmp_path
+
+
+def test_status_clean_then_dirty(repo):
+    cfg = {"cwd": str(repo)}
+    assert "clean" in tool_gitstatus({}, cfg).lower()
+    (repo / "a.txt").write_text("hello\nworld\n")
+    out = tool_gitstatus({}, cfg)
+    assert "a.txt" in out and "clean" not in out.lower()
+
+
+def test_diff_shows_stat_and_body(repo):
+    (repo / "a.txt").write_text("hello\nchanged\n")
+    out = tool_gitdiff({}, {"cwd": str(repo)})
+    assert "a.txt" in out and "changed" in out and "insertion" in out
+
+
+def test_diff_no_changes(repo):
+    assert "No changes" in tool_gitdiff({}, {"cwd": str(repo)})
+
+
+def test_log_lists_commits(repo):
+    out = tool_gitlog({"n": 5}, {"cwd": str(repo)})
+    assert "initial" in out
+
+
+def test_commit_stages_and_commits(repo):
+    (repo / "b.txt").write_text("new file\n")
+    out = tool_gitcommit({"message": "add b"}, {"cwd": str(repo)})
+    assert "Committed" in out
+    assert "add b" in tool_gitlog({}, {"cwd": str(repo)})
+
+
+def test_commit_empty_message_refused(repo):
+    (repo / "b.txt").write_text("x")
+    assert "non-empty message" in tool_gitcommit({"message": "  "}, {"cwd": str(repo)})
+
+
+def test_commit_nothing_to_commit(repo):
+    assert "Nothing to commit" in tool_gitcommit({"message": "noop"}, {"cwd": str(repo)})
+
+
+def test_not_a_repo_is_graceful(tmp_path):
+    out = tool_gitstatus({}, {"cwd": str(tmp_path)})
+    assert "not a git repository" in out.lower()
+
+
+def test_diff_truncates_large_body(repo):
+    # modify a TRACKED file so it appears in the working-tree diff
+    (repo / "a.txt").write_text("\n".join(f"line {i}" for i in range(5000)))
+    out = gittools.diff(str(repo), max_chars=1000)
+    assert "truncated" in out and len(out) < 4000

drydock_cli-3.0.52/tests/test_skills.py

@@ -0,0 +1,56 @@
+"""Skills: user-defined reusable /<name> slash commands loaded from markdown."""
+from __future__ import annotations
+
+from drydock import skills
+
+
+def _write(d, name, content):
+    d.mkdir(parents=True, exist_ok=True)
+    (d / name).write_text(content)
+
+
+def test_load_parses_frontmatter_and_body(tmp_path):
+    _write(tmp_path / ".drydock" / "skills", "review.md",
+           "---\nname: review\ndescription: Review the diff\n---\nRun GitDiff and review it.")
+    sk = skills.load_skills(str(tmp_path))
+    assert "review" in sk
+    assert sk["review"].description == "Review the diff"
+    assert sk["review"].body == "Run GitDiff and review it."
+
+
+def test_name_defaults_to_filename(tmp_path):
+    _write(tmp_path / ".drydock" / "skills", "explain.md", "Explain the selected code.")
+    sk = skills.load_skills(str(tmp_path))
+    assert "explain" in sk and sk["explain"].body == "Explain the selected code."
+
+
+def test_render_appends_args_without_placeholder(tmp_path):
+    _write(tmp_path / ".drydock" / "skills", "t.md", "Do the thing.")
+    sk = skills.load_skills(str(tmp_path))["t"]
+    assert sk.render("on auth.py") == "Do the thing.\n\non auth.py"
+    assert sk.render("") == "Do the thing."
+
+
+def test_render_substitutes_args_placeholder(tmp_path):
+    _write(tmp_path / ".drydock" / "skills", "t.md", "Focus on $ARGS and nothing else.")
+    sk = skills.load_skills(str(tmp_path))["t"]
+    assert sk.render("performance") == "Focus on performance and nothing else."
+
+
+def test_project_overrides_user(tmp_path, monkeypatch):
+    home = tmp_path / "home"
+    proj = tmp_path / "proj"
+    monkeypatch.setattr(skills.Path, "home", lambda: home)
+    _write(home / ".drydock" / "skills", "x.md", "USER version")
+    _write(proj / ".drydock" / "skills", "x.md", "PROJECT version")
+    sk = skills.load_skills(str(proj))
+    assert sk["x"].body == "PROJECT version"
+
+
+def test_empty_body_skipped(tmp_path):
+    _write(tmp_path / ".drydock" / "skills", "empty.md", "---\nname: empty\n---\n")
+    assert "empty" not in skills.load_skills(str(tmp_path))
+
+
+def test_no_skills_dir_is_empty(tmp_path):
+    assert skills.load_skills(str(tmp_path)) == {}