deepparallel 0.2.0__py3-none-any.whl

deepparallel/tools/sandbox.py

@@ -0,0 +1,110 @@
+"""Sandboxed code execution.
+
+Runs a snippet in an ephemeral Docker container when the daemon is reachable
+(real isolation: no network, memory cap), else falls back to a timeboxed local
+subprocess. Force a mode with DEEPPARALLEL_SANDBOX=docker|subprocess (default auto).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from deepparallel.tools import tool
+
+_LANGS = {
+    "python": {
+        "image": "python:3.12-slim",
+        "argv": ["python"],
+        "local": [sys.executable],
+        "ext": ".py",
+    },
+    "javascript": {"image": "node:20-slim", "argv": ["node"], "local": ["node"], "ext": ".js"},
+    "bash": {"image": "bash:5", "argv": ["bash"], "local": ["bash"], "ext": ".sh"},
+}
+_ALIASES = {"py": "python", "js": "javascript", "node": "javascript", "sh": "bash", "shell": "bash"}
+
+_MAX_OUT = 50_000
+
+
+def _docker_available() -> bool:
+    try:
+        proc = subprocess.run(["docker", "version"], capture_output=True, text=True, timeout=4)
+        return proc.returncode == 0
+    except Exception:  # noqa: BLE001 - any failure means no usable daemon
+        return False
+
+
+def _run(cmd: list[str], cwd: str | None, timeout: int):
+    proc = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, timeout=timeout)
+    return proc.stdout or "", proc.stderr or "", proc.returncode
+
+
+def _use_docker() -> bool:
+    mode = os.environ.get("DEEPPARALLEL_SANDBOX", "auto").strip().lower()
+    if mode == "docker":
+        return True
+    if mode == "subprocess":
+        return False
+    return _docker_available()
+
+
+@tool(dangerous=True)
+def run_code(language: str, code: str, timeout_seconds: int = 30) -> str:
+    """Execute a code snippet in a sandbox and capture its output.
+
+    :param language: One of python, javascript, bash.
+    :param code: Source code to run.
+    :param timeout_seconds: Maximum execution time in seconds.
+    """
+    lang = _ALIASES.get(language.strip().lower(), language.strip().lower())
+    spec = _LANGS.get(lang)
+    if spec is None:
+        return json.dumps({"error": f"unsupported language: {language}"})
+    timeout = min(int(timeout_seconds), 300)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        src = Path(tmp) / f"snippet{spec['ext']}"
+        src.write_text(code, encoding="utf-8")
+        if _use_docker():
+            sandbox = "docker"
+            cmd = [
+                "docker",
+                "run",
+                "--rm",
+                "--network",
+                "none",
+                "--memory",
+                "512m",
+                "-v",
+                f"{tmp}:/work",
+                "-w",
+                "/work",
+                spec["image"],
+                *spec["argv"],
+                src.name,
+            ]
+            cwd = None
+        else:
+            sandbox = "subprocess"
+            cmd = [*spec["local"], str(src)]
+            cwd = tmp
+        try:
+            stdout, stderr, rc = _run(cmd, cwd, timeout)
+        except subprocess.TimeoutExpired:
+            return json.dumps({"error": f"code timed out after {timeout}s", "sandbox": sandbox})
+        except FileNotFoundError as e:
+            return json.dumps({"error": f"runtime not available: {e}", "sandbox": sandbox})
+
+    return json.dumps(
+        {
+            "stdout": stdout[:_MAX_OUT],
+            "stderr": stderr[:10_000],
+            "exit_code": rc,
+            "sandbox": sandbox,
+        }
+    )

deepparallel/tools/search.py

@@ -0,0 +1,38 @@
+"""Content-search tool (grep)."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from deepparallel.tools import tool
+
+
+@tool(dangerous=False)
+def grep(dir_path: str, pattern: str, include: str = "**/*") -> str:
+    """Search file contents for a regular-expression pattern.
+
+    :param dir_path: Root directory to search.
+    :param pattern: Python regular expression.
+    :param include: Glob restricting which files are searched.
+    """
+    root = Path(dir_path).expanduser().resolve()
+    try:
+        rx = re.compile(pattern)
+    except re.error as e:
+        return json.dumps({"error": f"bad pattern: {e}"})
+    matches = []
+    for p in sorted(root.glob(include)):
+        if not p.is_file():
+            continue
+        try:
+            text = p.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        for i, line in enumerate(text.splitlines(), 1):
+            if rx.search(line):
+                matches.append({"path": str(p), "line_number": i, "line": line[:400]})
+                if len(matches) >= 500:
+                    return json.dumps({"matches": matches, "truncated": True})
+    return json.dumps({"matches": matches})

deepparallel/tools/shell.py

@@ -0,0 +1,38 @@
+"""Shell execution tool."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+
+from deepparallel.tools import tool
+
+
+@tool(dangerous=True)
+def run_shell(command: str, working_directory: str = "", timeout_seconds: int = 120) -> str:
+    """Run a shell command and capture its output.
+
+    :param command: Command to execute via the shell.
+    :param working_directory: Directory to run in (default: current).
+    :param timeout_seconds: Maximum execution time in seconds.
+    """
+    timeout_seconds = min(int(timeout_seconds), 600)
+    try:
+        r = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            cwd=working_directory or None,
+        )
+    except subprocess.TimeoutExpired:
+        return json.dumps(
+            {"error": f"Command timed out after {timeout_seconds}s", "return_code": -1}
+        )
+    stdout = r.stdout or ""
+    if len(stdout) > 50000:
+        stdout = stdout[:50000] + "\n... (output truncated at 50KB)"
+    return json.dumps(
+        {"stdout": stdout, "stderr": (r.stderr or "")[:10000], "return_code": r.returncode}
+    )

deepparallel/tools/vision.py

@@ -0,0 +1,54 @@
+"""Vision tool: analyze a local image with a multimodal deployment.
+
+The text backend (DeepParallel) is not multimodal, so this routes to a separate
+vision deployment named by DEEPPARALLEL_VISION_DEPLOYMENT, using the same transport.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import mimetypes
+import os
+from pathlib import Path
+
+from deepparallel.tools import tool
+
+
+@tool(dangerous=False)
+def analyze_image(image_path: str, prompt: str = "Describe this image in detail.") -> str:
+    """Analyze a local image with a vision model and return a description.
+
+    Requires DEEPPARALLEL_VISION_DEPLOYMENT (a multimodal deployment).
+
+    :param image_path: Path to a local image file.
+    :param prompt: What to ask about the image.
+    """
+    path = Path(image_path).expanduser().resolve()
+    if not path.is_file():
+        return json.dumps({"error": f"image not found: {image_path}"})
+    # Defaults to a multimodal deployment so vision works out of the box;
+    # override with DEEPPARALLEL_VISION_DEPLOYMENT.
+    deployment = (os.environ.get("DEEPPARALLEL_VISION_DEPLOYMENT") or "Llama-4-Scout").strip()
+
+    from deepparallel import backend as backend_mod
+    from deepparallel.config import resolve_settings
+
+    settings = resolve_settings()
+    data = base64.b64encode(path.read_bytes()).decode()
+    mime = mimetypes.guess_type(str(path))[0] or "image/png"
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": prompt},
+                {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{data}"}},
+            ],
+        }
+    ]
+    vision = backend_mod.backend_for_deployment(settings, deployment)
+    try:
+        msg = vision.chat(messages, [], settings.temperature, settings.max_tokens)
+    except Exception as e:  # noqa: BLE001 - surface vision failure to the model
+        return json.dumps({"error": f"vision call failed: {type(e).__name__}: {e}"})
+    return json.dumps({"description": (msg.get("content") or "").strip()})

deepparallel/tools/web.py

@@ -0,0 +1,76 @@
+"""Web tools: fetch a page's text, and search (key-gated)."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+
+import httpx
+
+from deepparallel.tools import tool
+
+_SCRIPT_STYLE = re.compile(r"<(script|style)\b[^>]*>.*?</\1>", re.IGNORECASE | re.DOTALL)
+_TAG = re.compile(r"<[^>]+>")
+_TITLE = re.compile(r"<title[^>]*>(.*?)</title>", re.IGNORECASE | re.DOTALL)
+_WS = re.compile(r"\s+")
+_TIMEOUT = 15.0
+_UA = "DeepParallel/0.1"
+
+
+@tool(dangerous=False)
+def web_fetch(url: str, max_chars: int = 8000) -> str:
+    """Fetch a web page and return its readable text (HTML stripped).
+
+    :param url: The URL to fetch.
+    :param max_chars: Maximum characters of text to return.
+    """
+    try:
+        r = httpx.get(url, timeout=_TIMEOUT, follow_redirects=True, headers={"user-agent": _UA})
+        r.raise_for_status()
+    except Exception as e:  # noqa: BLE001 - surface fetch failure to the model
+        return json.dumps({"error": f"fetch failed: {type(e).__name__}: {e}"})
+    html = r.text or ""
+    title_m = _TITLE.search(html)
+    title = _WS.sub(" ", _TAG.sub("", title_m.group(1))).strip() if title_m else ""
+    text = _WS.sub(" ", _TAG.sub(" ", _SCRIPT_STYLE.sub(" ", html))).strip()
+    return json.dumps({"url": url, "title": title, "text": text[:max_chars]})
+
+
+@tool(dangerous=False)
+def web_search(query: str, count: int = 5) -> str:
+    """Search the web and return result titles, URLs, and snippets.
+
+    Requires DEEPPARALLEL_SEARCH_API_KEY (Brave Search API by default).
+
+    :param query: The search query.
+    :param count: Maximum number of results.
+    """
+    key = os.environ.get("DEEPPARALLEL_SEARCH_API_KEY")
+    if not key:
+        return json.dumps(
+            {"error": "search not configured: set DEEPPARALLEL_SEARCH_API_KEY (Brave Search API)"}
+        )
+    url = os.environ.get(
+        "DEEPPARALLEL_SEARCH_URL", "https://api.search.brave.com/res/v1/web/search"
+    )
+    try:
+        r = httpx.get(
+            url,
+            params={"q": query, "count": count},
+            headers={"X-Subscription-Token": key, "accept": "application/json"},
+            timeout=_TIMEOUT,
+        )
+        r.raise_for_status()
+        data = r.json()
+    except Exception as e:  # noqa: BLE001 - surface search failure to the model
+        return json.dumps({"error": f"search failed: {type(e).__name__}: {e}"})
+    results = [
+        {
+            "title": item.get("title", ""),
+            "url": item.get("url", ""),
+            "snippet": item.get("description", ""),
+        }
+        for item in (data.get("web", {}).get("results") or [])[:count]
+    ]
+    return json.dumps({"results": results})

deepparallel-0.2.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: deepparallel
+Version: 0.2.0
+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
+Project-URL: Homepage, https://crowelogic.com
+Keywords: deepparallel,agent,coding-agent,cli,llm,code-review,crowe-logic
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: tree-sitter>=0.25.0
+Requires-Dist: tree-sitter-language-pack>=1.8.0
+Requires-Dist: cryptography>=42.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+
+# DeepParallel
+
+A focused command-line interface for the DeepParallel model, served via Crowe Logic.
+
+## Install
+
+    uv venv
+    uv pip install -p .venv -e .
+
+## Configure
+
+Set the backend env vars (a `.env` file in the working directory is loaded automatically):
+
+    # default backend: azure
+    AZURE_CORE_ENDPOINT=https://<resource>.openai.azure.com
+    AZURE_CORE_API_KEY=<key>
+    # optional overrides
+    DEEPPARALLEL_API_VERSION=2024-08-01-preview
+
+    # or route through the Crowe Logic Foundry control plane:
+    DEEPPARALLEL_BACKEND=foundry
+    FOUNDRY_BASE_URL=https://<control-plane>
+    FOUNDRY_API_KEY=<token>
+
+## Use
+
+    deepparallel                 # interactive agent chat
+    deepparallel run "question"  # one-shot, pipe-friendly (answer on stdout)
+    deepparallel tools           # list the agent's tools
+    deepparallel info            # model + backend status
+    deepparallel doctor          # diagnose config + reachability
+    deepparallel run --no-tools "..."   # plain chat, no tools
+    deepparallel run --yes "..."        # auto-approve tool actions
+
+## Fusion (stacking models for stronger output)
+
+`deepparallel` can stack the answerer with a separate reasoning model. All modes
+compose hosted backends (no GPU/weight-merging), so they are API-call stacking.
+
+    deepparallel run --fuse reason "hard question"     # reasoner thinks, answerer answers
+    deepparallel run --fuse escalate "question"        # answer first; escalate to reasoner only if unsure
+    deepparallel run --deep "question"                 # heavy: many models in parallel + a judge (slow)
+    deepparallel run --dual "A,B" "question"           # compare two deployments side by side
+    deepparallel run --dual "A,B" --synth "question"   # ...and synthesize a merged answer
+
+`--fuse` also works in interactive chat. Set a default with `DEEPPARALLEL_FUSION=reason`.
+
+## Fusion-native UX (what single-model agents cannot do)
+
+- **Guardian review** - before an edit (`write_file` / `edit_file` / `ast_replace_symbol`)
+  is applied, a second model reviews the diff and its verdict
+  (`safe` / `risky: ...` / `bug: ...`) is shown in the confirm card. Advisory:
+  you still approve. Toggle with `DEEPPARALLEL_GUARDIAN`; pick the reviewer with
+  `DEEPPARALLEL_GUARDIAN_DEPLOYMENT`.
+- **Consensus + divergence** - `run --deep` prints a `consensus:` chip from
+  cross-model agreement (agreement, not correctness), and on low agreement
+  lists the dissenting candidates.
+- **Live dial** - in interactive chat, `/fast`, `/fuse`, `/escalate` switch the
+  fusion mode mid-session (shown in the prompt); `/deep` runs the next prompt as
+  a multi-model query.
+
+## Agent and tools
+
+`deepparallel` is an agent: it can call tools to inspect and change your project.
+
+- Read-only (run automatically): `read_file`, `list_dir`, `glob`, `grep`,
+  `ast_symbols`, `ast_show_symbol`, `web_fetch`, `web_search`, `analyze_image`.
+- Mutating / executing (require confirmation): `write_file`, `edit_file`,
+  `ast_replace_symbol`, `run_shell`, `run_code`.
+
+`web_search` needs `DEEPPARALLEL_SEARCH_API_KEY`; `analyze_image` works out of the
+box on a multimodal deployment (override with `DEEPPARALLEL_VISION_DEPLOYMENT`).
+
+In interactive chat, mutating actions prompt for y/n. In `run` (non-interactive)
+they are denied unless you pass `--yes`. `ast_*` tools are multi-language via
+tree-sitter; `run_code` executes in a Docker sandbox when available, else a
+timeboxed local subprocess.
+
+## Configuration reference
+
+| Variable | Purpose | Default |
+|---|---|---|
+| `DEEPPARALLEL_BACKEND` | `azure` or `foundry` | `azure` |
+| `AZURE_CORE_ENDPOINT` / `AZURE_CORE_API_KEY` | Azure transport | (required for azure) |
+| `DEEPPARALLEL_API_VERSION` | Azure API version | `2024-08-01-preview` |
+| `FOUNDRY_BASE_URL` / `FOUNDRY_API_KEY` | control-plane transport | (required for foundry) |
+| `DEEPPARALLEL_TEMPERATURE` | default sampling temperature | `0.4` |
+| `DEEPPARALLEL_MAX_TOKENS` | response cap | `2048` |
+| `DEEPPARALLEL_THINK` | surface reasoning stream | `0` (answer-only) |
+| `DEEPPARALLEL_TOOLS` | enable agent tools | `1` (on) |
+| `DEEPPARALLEL_AUTO_APPROVE` | auto-approve mutating tools | `0` (off) |
+| `DEEPPARALLEL_MAX_STEPS` | max agent tool-call rounds | `12` |
+| `DEEPPARALLEL_SHELL_TIMEOUT` | run_shell timeout (s) | `120` |
+| `DEEPPARALLEL_SANDBOX` | `auto` / `docker` / `subprocess` for run_code | `auto` |
+| `DEEPPARALLEL_PLAIN` | force plain (non-rich) output | `0` |
+| `DEEPPARALLEL_FUSION` | default fusion: `off` / `reason` / `escalate` | `off` |
+| `DEEPPARALLEL_REASONER_DEPLOYMENT` | reasoner model for fusion | `DeepSeek-R1-0528` |
+| `DEEPPARALLEL_PARALLEL_MODELS` | comma-separated chains for `--deep` | (three defaults) |
+| `DEEPPARALLEL_JUDGE_DEPLOYMENT` | judge/synthesizer model | the primary deployment |
+| `DEEPPARALLEL_SEARCH_API_KEY` | enables web_search (Brave Search API) | (unset) |
+| `DEEPPARALLEL_SEARCH_URL` | search API endpoint | Brave web search |
+| `DEEPPARALLEL_VISION_DEPLOYMENT` | multimodal model for analyze_image | `Llama-4-Scout` |
+| `DEEPPARALLEL_GUARDIAN` | second-model review of edits before apply | `1` (on) |
+| `DEEPPARALLEL_GUARDIAN_DEPLOYMENT` | the reviewer model | the reasoner |
+
+DeepParallel is served via Crowe Logic infrastructure. https://crowelogic.com

deepparallel-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+deepparallel/__init__.py,sha256=dcRd-DGbeCsxhE2nBkRv6XCRb0Gsg3zBKc7vcf-4h8o,55
+deepparallel/agent.py,sha256=HH8IntUvRF6sbOKXOP3RYstVGV6XllNhRY0vv2p3EII,10598
+deepparallel/backend.py,sha256=rKlpilOb3Wj8PkjK5OlYZg7p-0_UxY3pe6A_lMFY85Q,10257
+deepparallel/branding.py,sha256=40FmA2syEK6gjzD886HeL5obaKMWROTxc_IveiTuntA,7208
+deepparallel/cli.py,sha256=fVjwiXeeN7aHGF9fKa0e4J6PJ0FKd262ocFqLCaBH-Q,20217
+deepparallel/config.py,sha256=G6xt7oyV89h8veJEZiA0KM6U-KozUHGjJhdbsIF6gss,5255
+deepparallel/fusion.py,sha256=GoMJMmg5TkZDFpjNqo1dAEo7-Xuc0C_kyd7MHtyzR04,8265
+deepparallel/licensing.py,sha256=1vG_VBuovNIjIy674Ej1w55wRSU8owc3XNSnwm4WrS8,3558
+deepparallel/registry.json,sha256=HHKm4tIOHFGO9KR0Z2dEQMIo4qTUlAswE_IzNv187Q0,298
+deepparallel/renderer.py,sha256=pW0bA1-1WN2DgawbZKAwT_vtaRVTUFLztdClLKfFhdI,7759
+deepparallel/system_prompt.txt,sha256=WBWszuTW9B25DK0I584QVbcoo-fGCDV8hFs1qBv5H8g,667
+deepparallel/tools/__init__.py,sha256=vgZQtfEIxH39Qho6hhpUo6rsYtZu4moEfcx7KINpQBk,611
+deepparallel/tools/codeast.py,sha256=6wlH6XsBx39Jkizj7P0Wkb1_PyWxfZt1EA0SzXF-hWY,5860
+deepparallel/tools/edit.py,sha256=puT4x6FTG54MqiE3ur1EL6YVQwg66f5rmT7AE5CUgAY,1060
+deepparallel/tools/files.py,sha256=aydsTgovEsoCWNwp2y4V3afDa8p8oIBeZA5tXXw175g,2667
+deepparallel/tools/registry.py,sha256=Eqv_VcWToZbPuOCvNul6_jx1ItAxEt7OLMP4eCr_XQw,4612
+deepparallel/tools/sandbox.py,sha256=WZhsZnkVUnC1ZTDAgyoIUO4C8sUvZHab6Ji3ftfSu_o,3459
+deepparallel/tools/search.py,sha256=jsX0ieouuUZzkWsgDrtwzVF-aV36NetarFqmQy4mT-4,1222
+deepparallel/tools/shell.py,sha256=DjUGBT5DKYPNplEgMIpCy6z5ss7agbzlV2cby9LjGZo,1186
+deepparallel/tools/vision.py,sha256=Nm8uIDllyaa6ucfgmzdM_272H1EVW27fO2ALybw6n0w,2044
+deepparallel/tools/web.py,sha256=Q3HZ0uAOyHWt4EV9q-gNLdcp1zOOB0QDXhjgRX70YeY,2647
+deepparallel-0.2.0.dist-info/METADATA,sha256=HY1ZGm6Rcht5yNrFGgYXnTfXeFeR056B80aniTLfAsQ,6110
+deepparallel-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+deepparallel-0.2.0.dist-info/entry_points.txt,sha256=1WPP0AaAhVqet5SvmVlFj-SdkY4cYWGVXy12mAHTTXs,82
+deepparallel-0.2.0.dist-info/top_level.txt,sha256=KpyrGzNnWKi_qNljdM2Z5dyfMAff_-6_lpDZv07NcEc,13
+deepparallel-0.2.0.dist-info/RECORD,,

deepparallel-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

deepparallel-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+deepparallel = deepparallel.cli:main
+dp = deepparallel.cli:main

deepparallel-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+deepparallel