deepparallel 0.5.4__tar.gz → 0.5.7__tar.gz

{deepparallel-0.5.4 → deepparallel-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.4
+Version: 0.5.7
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0

{deepparallel-0.5.4 → deepparallel-0.5.7}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.5.4"
+__version__ = "0.5.7"

{deepparallel-0.5.4 → deepparallel-0.5.7}/deepparallel/branding.py

@@ -373,12 +373,12 @@ def status_text(
     body.append(f"  {DOT} v{version}  {DOT} ", style=DIM)
     body.append("served via Crowe Logic\n", style=f"bold {CROWE_ACCENT}")
     body.append(f"{tool_count} tools", style=WHITE_HEX)
-    body.append(f" {DOT} 5,800+ MCP servers", style=DIM)
-    body.append(f"  {DOT} fusion: {fusion}\n", style=DIM)
+    body.append(f" {DOT} MCP registry (local + 5,800+)", style=DIM)
+    body.append(f"  {DOT} memory {DOT} fusion: {fusion}\n", style=DIM)
     body.append("Backend: ", style=DIM)
     body.append(f"{backend_label}\n\n", style="white")
     body.append("/help", style="bold")
-    body.append("  /tools  /fast //deep //fuse  ", style=DIM)
+    body.append("  /tools  /memory  /cockpit  /fast //deep //fuse  ", style=DIM)
     body.append("/quit", style="bold")
     return _gutter(body)
 

{deepparallel-0.5.4 → deepparallel-0.5.7}/deepparallel/cli.py

@@ -17,7 +17,6 @@ apply to chat and run.
 from __future__ import annotations
 
 import os
-import subprocess
 import sys
 from dataclasses import replace
 from pathlib import Path
@@ -46,7 +45,7 @@ from deepparallel.config import (
     missing_required,
     resolve_settings,
 )
-from deepparallel import licensing, supply_chain
+from deepparallel import licensing, memory, supply_chain
 from deepparallel.fusion import (
     EscalationBackend,
     ReasonAnswerBackend,
@@ -178,6 +177,11 @@ def _build_guardian(settings: Settings) -> Backend | None:
     return backend_for_deployment(settings, settings.guardian_deployment)
 
 
+def _system_prompt() -> str:
+    """System prompt with the long-term memory index injected (recall tier 1)."""
+    return load_system_prompt() + memory.index_block()
+
+
 def _make_renderer(*, force_plain: bool, assume_yes: bool = False) -> Renderer:
     plain = force_plain or _bool_env("DEEPPARALLEL_PLAIN", False) or not sys.stdout.isatty()
     if plain:
@@ -234,7 +238,7 @@ def _stream_once(backend: Backend, settings: Settings, messages: list[dict]) ->
 
 def _stream_repl(backend: Backend, settings: Settings) -> None:
     """Plain-chat interactive loop (no tools)."""
-    system = load_system_prompt()
+    system = _system_prompt()
     history: list[tuple[str, str]] = []
     while True:
         try:
@@ -290,11 +294,18 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
     (/fast //fuse //escalate //deep) swaps the active fusion mode live."""
     registry = get_registry()
     guardian = _build_guardian(settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages: list[dict] = [{"role": "system", "content": system}]
     mode = settings.fusion_mode if settings.fusion_mode in ("reason", "escalate") else "off"
     deep_next = False
     auto = settings.auto_approve
+    cockpit = Cockpit(os.path.abspath(os.path.join(".cockpit", "events.jsonl")))
+    cockpit_on = cockpit.in_waveterm()
+    observer = make_observer(cockpit)
+    if cockpit_on:
+        cockpit.events_path.parent.mkdir(parents=True, exist_ok=True)
+        cockpit.events_path.write_text("")
+        cockpit.status("start", "cockpit ready")
     while True:
         bits = ([mode] if mode != "off" else []) + (["auto"] if auto else [])
         tag = f"[{' · '.join(bits)}] " if bits else ""
@@ -309,7 +320,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
             break
         if user_msg == "/help":
             branding.info(
-                "/quit · /reset · /info · /tools · /auto · /fast //fuse //escalate //deep · prompt"
+                "/quit · /reset · /info · /tools · /auto · /memory · /cockpit · /fast //fuse //escalate //deep · prompt"
             )
             continue
         if user_msg in {"/auto", "/yes"}:
@@ -337,6 +348,26 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
             deep_next = True
             branding.info("next prompt runs as a multi-model deep query")
             continue
+        if user_msg == "/cockpit":
+            cockpit_on = not cockpit_on
+            if cockpit_on:
+                cockpit.events_path.parent.mkdir(parents=True, exist_ok=True)
+                cockpit.events_path.write_text("")
+                cockpit._panel_opened = False
+                branding.info("cockpit ON - the data window opens when research starts.")
+            else:
+                cockpit.status("done", "cockpit complete")
+                branding.info("cockpit OFF.")
+            continue
+        if user_msg == "/memory":
+            mems = memory.list_memories()
+            if mems:
+                branding.info(f"{len(mems)} memories saved. Most recent:")
+                for m in mems[-8:]:
+                    console.print(f"  [dim]-[/] {m['name']}: {m['description'][:64]}")
+            else:
+                branding.info("no memories yet; the agent saves them with the remember tool.")
+            continue
 
         messages.append({"role": "user", "content": user_msg})
         if deep_next:
@@ -354,12 +385,15 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
                 auto_approve=auto,
                 stream=True,
                 guardian=guardian,
+                on_event=observer if cockpit_on else None,
             )
             if mode in ("reason", "escalate"):
                 branding.info("reasoned by CroweLM Reason · answered by DeepParallel")
         except Exception as e:  # noqa: BLE001 - surface as friendly message
             renderer.error(_translate_error(e))
 
+    if cockpit_on:
+        cockpit.status("done", "cockpit complete")
     branding.attribution_footer()
 
 
@@ -462,7 +496,7 @@ def run(
     if fuse is not None:
         settings = replace(settings, fusion_mode=fuse)
     backend = _require_ready(settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages = _build_messages([], system, " ".join(prompt))
     if deep:
         _run_deep(settings, messages)
@@ -508,17 +542,9 @@ def cockpit(ctx: click.Context, assume_yes: bool, prompt: tuple[str, ...]) -> No
     open(events_path, "w").close()
     cp = Cockpit(events_path)
     cp.status("start", "cockpit online")
-    if cp.in_waveterm():
-        try:
-            subprocess.Popen(
-                ["wsh", "run", "--", "dp", "_cockpit-panel", events_path],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-        except Exception:  # noqa: BLE001 - the panel block is best-effort
-            pass
+    cp.ensure_panel()
     backend = _wrap_fusion(backend, settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages = _build_messages([], system, " ".join(prompt))
     renderer = _make_renderer(force_plain=False, assume_yes=settings.auto_approve)
     try:

{deepparallel-0.5.4 → deepparallel-0.5.7}/deepparallel/cockpit.py

@@ -45,6 +45,7 @@ class Cockpit:
 
     def __init__(self, events_path: str = ".cockpit/events.jsonl"):
         self.events_path = Path(events_path)
+        self._panel_opened = False
 
     # --- environment -------------------------------------------------------
 
@@ -119,6 +120,25 @@ class Cockpit:
         """Best-effort `wsh notify`. Silent no-op off WaveTerm or on failure."""
         self._run_wsh(["notify", message])
 
+    def ensure_panel(self) -> None:
+        """Open the live data-window block once per session (idempotent).
+
+        Spawns `dp _cockpit-panel <abs-path>` in an adjacent WaveTerm block on
+        the first call so the cockpit appears only when research actually
+        starts; repeat calls and runs outside WaveTerm are no-ops.
+        """
+        if self._panel_opened or not self.in_waveterm():
+            return
+        self._panel_opened = True
+        try:
+            subprocess.Popen(
+                ["wsh", "run", "--", "dp", "_cockpit-panel", str(self.events_path.resolve())],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except Exception:  # noqa: BLE001 - the panel block is best-effort
+            pass
+
     # --- contract event helpers -------------------------------------------
 
     def status(self, phase: str, message: str) -> None:

{deepparallel-0.5.4 → deepparallel-0.5.7}/deepparallel/cockpit_observe.py

@@ -31,8 +31,11 @@ def make_observer(cockpit) -> Callable[[str, dict, str], None]:
         try:
             if isinstance(obj, dict) and "error" not in obj:
                 if name == "web_search":
+                    results = obj.get("results") or []
+                    if results:
+                        cockpit.ensure_panel()
                     provider = obj.get("provider", "web")
-                    for r in (obj.get("results") or [])[:8]:
+                    for r in results[:8]:
                         url = r.get("url")
                         if not url:
                             continue
@@ -45,11 +48,15 @@ def make_observer(cockpit) -> Callable[[str, dict, str], None]:
                 elif name == "web_fetch":
                     url = obj.get("url") or (args or {}).get("url", "")
                     if url:
+                        cockpit.ensure_panel()
                         cockpit.source(url=url, title=obj.get("title", ""), provider="fetch")
                         if counters["blocks"] < _MAX_WEB_BLOCKS and cockpit.open_web(url):
                             counters["blocks"] += 1
                 elif name == "mcp_search":
-                    for s in (obj.get("servers") or [])[:5]:
+                    servers = obj.get("servers") or []
+                    if servers:
+                        cockpit.ensure_panel()
+                    for s in servers[:5]:
                         cockpit.source(url="", title=s.get("name", ""), provider="mcp")
             cockpit.status("tool", name)
         except Exception:  # noqa: BLE001 - observation must never break the loop

{deepparallel-0.5.4 → deepparallel-0.5.7}/deepparallel/config.py

@@ -104,7 +104,54 @@ def _int_env(name: str, default: int) -> int:
         return default
 
 
+_TOML_TO_ENV = {
+    "backend.backend": "DEEPPARALLEL_BACKEND",
+    "backend.deployment": "DEEPPARALLEL_DEPLOYMENT",
+    "backend.temperature": "DEEPPARALLEL_TEMPERATURE",
+    "backend.max_tokens": "DEEPPARALLEL_MAX_TOKENS",
+    "backend.parallel_models": "DEEPPARALLEL_PARALLEL_MODELS",
+    "fusion.mode": "DEEPPARALLEL_FUSION",
+    "tools.auto_approve": "DEEPPARALLEL_AUTO_APPROVE",
+    "memory.enabled": "DEEPPARALLEL_MEMORY",
+    "memory.dir": "DEEPPARALLEL_MEMORY_DIR",
+    "mcp.config": "DEEPPARALLEL_MCP_CONFIG",
+}
+
+
+def _apply_config_file() -> None:
+    """Layer ~/.config/deepparallel/config.toml under the environment.
+
+    Sets each known DEEPPARALLEL_* env var only when unset, so precedence is
+    explicit env var > config.toml > built-in default. Missing or malformed
+    config is ignored. Path override: DEEPPARALLEL_CONFIG.
+    """
+    import tomllib
+
+    path = os.environ.get("DEEPPARALLEL_CONFIG") or os.path.expanduser(
+        "~/.config/deepparallel/config.toml"
+    )
+    try:
+        with open(path, "rb") as fh:
+            data = tomllib.load(fh)
+    except (OSError, ValueError):
+        return
+    for dotted, env_name in _TOML_TO_ENV.items():
+        if os.environ.get(env_name) is not None:
+            continue
+        section, key = dotted.split(".", 1)
+        val = (data.get(section) or {}).get(key)
+        if val is None:
+            continue
+        if isinstance(val, bool):
+            os.environ[env_name] = "true" if val else "false"
+        elif isinstance(val, list):
+            os.environ[env_name] = ",".join(str(x) for x in val)
+        else:
+            os.environ[env_name] = str(val)
+
+
 def resolve_settings() -> Settings:
+    _apply_config_file()
     backend = os.environ.get("DEEPPARALLEL_BACKEND", "azure").strip().lower()
     if backend not in {"azure", "foundry", "crowe", "openai", "ollama"}:
         backend = "azure"

deepparallel-0.5.7/deepparallel/memory.py

@@ -0,0 +1,186 @@
+# Copyright 2026, Crowe Logic Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Persistent, continuously-growing memory for DeepParallel.
+
+This is what makes CroweLM a learning model in practice: durable facts persist
+across sessions and feed back into context. Two recall tiers:
+
+- index: MEMORY.md is injected into the system prompt every session, so the
+  model remembers the user and their projects without being re-told.
+- retrieval: recall(query) ranks individual memories by relevance (TF-IDF
+  cosine over tokens, stdlib only) for an on-demand, semantic-style pull.
+
+Memories are markdown files with frontmatter under the memory directory
+(default ~/.config/deepparallel/memory; override DEEPPARALLEL_MEMORY_DIR).
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import time
+from pathlib import Path
+
+INDEX_FILE = "MEMORY.md"
+_SLUG_RE = re.compile(r"[^a-z0-9]+")
+_TOK_RE = re.compile(r"[a-z0-9]+")
+_FM_RE = re.compile(r"^---\n(.*?)\n---\n?(.*)$", re.S)
+
+
+def memory_dir() -> Path:
+    raw = os.environ.get("DEEPPARALLEL_MEMORY_DIR") or os.path.expanduser(
+        "~/.config/deepparallel/memory"
+    )
+    return Path(raw)
+
+
+def enabled() -> bool:
+    return os.environ.get("DEEPPARALLEL_MEMORY", "on").strip().lower() not in {
+        "0", "off", "false", "no",
+    }
+
+
+def _slugify(name: str) -> str:
+    return _SLUG_RE.sub("-", name.strip().lower()).strip("-") or "memory"
+
+
+def _unique_slug(d: Path, slug: str) -> str:
+    cand, i = slug, 2
+    while (d / f"{cand}.md").exists():
+        cand, i = f"{slug}-{i}", i + 1
+    return cand
+
+
+def load_index() -> str:
+    try:
+        return (memory_dir() / INDEX_FILE).read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def index_block() -> str:
+    """The memory index formatted for system-prompt injection (empty if none)."""
+    idx = load_index()
+    if not idx or not enabled():
+        return ""
+    return (
+        "\n\nLong-term memory (recalled from past sessions; background context, "
+        "verify file/line specifics before relying on them):\n" + idx
+    )
+
+
+def save_memory(content: str, name: str = "", description: str = "", mtype: str = "note") -> str:
+    """Write one durable fact as a markdown file and add an index line."""
+    d = memory_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    first_line = content.strip().split("\n", 1)[0]
+    title = (name or first_line)[:60].strip() or "memory"
+    slug = _unique_slug(d, _slugify(title))
+    desc = (description or first_line).replace("\n", " ").strip()[:120]
+    body = (
+        f"---\nname: {title}\ndescription: {desc}\ntype: {mtype}\n"
+        f"created: {int(time.time())}\n---\n\n{content.strip()}\n"
+    )
+    (d / f"{slug}.md").write_text(body, encoding="utf-8")
+    _append_index(d, slug, title, desc)
+    return slug
+
+
+def _append_index(d: Path, slug: str, title: str, desc: str) -> None:
+    idx = d / INDEX_FILE
+    existing = idx.read_text(encoding="utf-8") if idx.exists() else "# DeepParallel Memory\n\n"
+    if f"]({slug}.md)" in existing:
+        return
+    if not existing.endswith("\n"):
+        existing += "\n"
+    idx.write_text(existing + f"- [{title}]({slug}.md) - {desc}\n", encoding="utf-8")
+
+
+def _parse(text: str, fallback: str) -> tuple[str, str, str]:
+    m = _FM_RE.match(text)
+    if not m:
+        return fallback, "", text.strip()
+    meta = {}
+    for line in m.group(1).splitlines():
+        if ":" in line:
+            k, v = line.split(":", 1)
+            meta[k.strip()] = v.strip()
+    return meta.get("name", fallback), meta.get("description", ""), m.group(2).strip()
+
+
+def list_memories() -> list[dict]:
+    d = memory_dir()
+    out = []
+    if not d.exists():
+        return out
+    for p in sorted(d.glob("*.md")):
+        if p.name == INDEX_FILE:
+            continue
+        name, desc, body = _parse(p.read_text(encoding="utf-8", errors="replace"), p.stem)
+        out.append({"name": name, "description": desc, "content": body, "path": str(p)})
+    return out
+
+
+def _tokenize(text: str) -> list[str]:
+    return _TOK_RE.findall(text.lower())
+
+
+def recall(query: str, limit: int = 5) -> list[dict]:
+    """Relevance-ranked memories via TF-IDF cosine over tokens (stdlib only)."""
+    mems = list_memories()
+    if not mems or not query.strip():
+        return []
+    docs = [_tokenize(f"{m['name']} {m['description']} {m['content']}") for m in mems]
+    df: dict[str, int] = {}
+    for toks in docs:
+        for t in set(toks):
+            df[t] = df.get(t, 0) + 1
+    n = len(docs)
+
+    def vec(toks: list[str]) -> dict[str, float]:
+        if not toks:
+            return {}
+        tf: dict[str, int] = {}
+        for t in toks:
+            tf[t] = tf.get(t, 0) + 1
+        return {t: (c / len(toks)) * math.log((n + 1) / (df.get(t, 0) + 1) + 1) for t, c in tf.items()}
+
+    qv = vec(_tokenize(query))
+    qa = math.sqrt(sum(v * v for v in qv.values()))
+    scored = []
+    for m, toks in zip(mems, docs):
+        dv = vec(toks)
+        da = math.sqrt(sum(v * v for v in dv.values()))
+        num = sum(qv.get(t, 0.0) * dv.get(t, 0.0) for t in qv)
+        score = num / (da * qa) if da and qa else 0.0
+        if score > 0:
+            scored.append(
+                {"name": m["name"], "description": m["description"], "content": m["content"],
+                 "score": round(score, 4)}
+            )
+    scored.sort(key=lambda x: x["score"], reverse=True)
+    return scored[:limit]
+
+
+def _rebuild_index(d: Path) -> None:
+    lines = ["# DeepParallel Memory", ""]
+    for m in list_memories():
+        lines.append(f"- [{m['name']}]({Path(m['path']).stem}.md) - {m['description']}")
+    (d / INDEX_FILE).write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def forget(name: str) -> bool:
+    d = memory_dir()
+    target = d / f"{_slugify(name)}.md"
+    if not target.exists():
+        for p in d.glob("*.md"):
+            if p.stem == name and p.name != INDEX_FILE:
+                target = p
+                break
+    if target.exists() and target.name != INDEX_FILE:
+        target.unlink()
+        _rebuild_index(d)
+        return True
+    return False

{deepparallel-0.5.4 → deepparallel-0.5.7}/deepparallel/tools/__init__.py

@@ -19,7 +19,9 @@ from deepparallel.tools import (  # noqa: E402,F401
     codeast,
     edit,
     files,
+    git_ops,
     mcp,
+    memory,
     sandbox,
     search,
     shell,

deepparallel-0.5.7/deepparallel/tools/git_ops.py

@@ -0,0 +1,185 @@
+"""Git operations tools: status, diff, log, branch, add, commit, clone."""
+
+from __future__ import annotations
+
+import json
+import shlex
+import subprocess
+from pathlib import Path
+
+from deepparallel.tools import tool
+
+
+def _repo(repo_path: str) -> Path:
+    return Path(repo_path).expanduser().resolve()
+
+
+def _is_repo(repo: Path) -> bool:
+    try:
+        r = subprocess.run(
+            ["git", "-C", str(repo), "rev-parse", "--git-dir"],
+            capture_output=True, text=True, timeout=10,
+        )
+        return r.returncode == 0
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _run_git(repo: Path, args: list[str], timeout_seconds: int = 30) -> dict:
+    """Run a git command in repo and return a result dict.
+
+    Surfaces failures as {"error": ...} instead of raising.
+    """
+    try:
+        r = subprocess.run(
+            ["git", *args],
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            cwd=str(repo),
+        )
+    except FileNotFoundError:
+        return {"error": "git executable not found on PATH"}
+    except subprocess.TimeoutExpired:
+        return {"error": f"git command timed out after {timeout_seconds}s"}
+    except Exception as e:  # noqa: BLE001 - surface failure to the model
+        return {"error": f"{type(e).__name__}: {e}"}
+    stdout = r.stdout or ""
+    if len(stdout) > 50000:
+        stdout = stdout[:50000] + "\n... (output truncated at 50KB)"
+    return {
+        "output": stdout.strip(),
+        "stderr": (r.stderr or "").strip()[:10000],
+        "return_code": r.returncode,
+    }
+
+
+@tool(dangerous=False)
+def git_status(repo_path: str) -> str:
+    """Show the working tree status of a git repository.
+
+    :param repo_path: Path to the git repository.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    return json.dumps(_run_git(repo, ["status", "--porcelain=v2", "--branch"]))
+
+
+@tool(dangerous=False)
+def git_diff(repo_path: str, staged: bool = False) -> str:
+    """Show changes in the working directory or staging area.
+
+    :param repo_path: Path to the git repository.
+    :param staged: If true, show staged changes; default shows unstaged changes.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    args = ["diff"]
+    if staged:
+        args.append("--cached")
+    return json.dumps(_run_git(repo, args))
+
+
+@tool(dangerous=False)
+def git_log(repo_path: str, count: int = 10) -> str:
+    """Show recent commit history as one line per commit.
+
+    :param repo_path: Path to the git repository.
+    :param count: Number of commits to show (capped at 50).
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    count = max(1, min(int(count), 50))
+    return json.dumps(_run_git(repo, ["log", f"-{count}", "--oneline", "--decorate"]))
+
+
+@tool(dangerous=False)
+def git_branch(repo_path: str) -> str:
+    """List branches and report the current branch.
+
+    :param repo_path: Path to the git repository.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    listing = _run_git(repo, ["branch", "--list"])
+    if "error" in listing:
+        return json.dumps(listing)
+    current = _run_git(repo, ["rev-parse", "--abbrev-ref", "HEAD"])
+    branches = []
+    for line in listing["output"].splitlines():
+        name = line.replace("*", "", 1).strip()
+        if name:
+            branches.append(name)
+    return json.dumps(
+        {
+            "branches": branches,
+            "current": current.get("output", ""),
+            "return_code": listing["return_code"],
+        }
+    )
+
+
+@tool(dangerous=True)
+def git_add(repo_path: str, paths: str = ".") -> str:
+    """Stage files for the next commit.
+
+    :param repo_path: Path to the git repository.
+    :param paths: Space-separated pathspecs to stage (default "." for all).
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    pathspecs = shlex.split(paths) if paths.strip() else ["."]
+    return json.dumps(_run_git(repo, ["add", "--", *pathspecs]))
+
+
+@tool(dangerous=True)
+def git_commit(repo_path: str, message: str, add_all: bool = False) -> str:
+    """Create a commit, optionally staging all tracked changes first.
+
+    :param repo_path: Path to the git repository.
+    :param message: The commit message.
+    :param add_all: If true, stage all tracked changes before committing.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    args = ["commit", "-m", message]
+    if add_all:
+        args.append("--all")
+    return json.dumps(_run_git(repo, args))
+
+
+@tool(dangerous=True)
+def git_clone(url: str, target_path: str) -> str:
+    """Clone a git repository into a local path.
+
+    :param url: The repository URL to clone.
+    :param target_path: Local path to clone into.
+    """
+    target = Path(target_path).expanduser().resolve()
+    try:
+        r = subprocess.run(
+            ["git", "clone", url, str(target)],
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+    except FileNotFoundError:
+        return json.dumps({"error": "git executable not found on PATH"})
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": "git clone timed out after 300s"})
+    except Exception as e:  # noqa: BLE001 - surface failure to the model
+        return json.dumps({"error": f"{type(e).__name__}: {e}"})
+    return json.dumps(
+        {
+            "output": (r.stdout or "").strip(),
+            "stderr": (r.stderr or "").strip()[:10000],
+            "return_code": r.returncode,
+            "target_path": str(target),
+        }
+    )