deepparallel 0.2.0__tar.gz

deepparallel-0.2.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,106 @@
+# 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/deepparallel/__init__.py

@@ -0,0 +1,3 @@
+"""DeepParallel CLI package."""
+
+__version__ = "0.2.0"

deepparallel-0.2.0/deepparallel/agent.py

@@ -0,0 +1,286 @@
+"""The agentic tool-calling loop.
+
+UI-agnostic: it drives a backend (`chat`) and a tool registry, and surfaces
+activity through an injected renderer. Dangerous tools are gated; the loop
+terminates on a content answer or a step cap.
+"""
+
+from __future__ import annotations
+
+import difflib
+import json
+import time
+from pathlib import Path
+
+from deepparallel.tools.registry import coerce_args
+
+_MAX_TOOL_RESULT = 50_000
+_GATED_PATH_TOOLS = ("write_file", "edit_file")
+_EDIT_TOOLS = ("write_file", "edit_file", "ast_replace_symbol")
+
+
+def _parse_args(raw: str) -> dict:
+    if not raw:
+        return {}
+    try:
+        value = json.loads(raw)
+    except json.JSONDecodeError:
+        return {"__parse_error__": raw[:2000]}
+    return value if isinstance(value, dict) else {}
+
+
+def _plural(n: int, sing: str, plur: str) -> str:
+    return f"{n} {sing if n == 1 else plur}"
+
+
+def _summarize_result(name: str, result: str) -> str:
+    """A short, human-readable summary of a tool result for the UI.
+
+    The model still receives the full result; this is only what the user sees
+    on the tool card, so it must be legible rather than raw truncated JSON.
+    """
+    try:
+        obj = json.loads(result)
+    except (json.JSONDecodeError, ValueError):
+        obj = None
+    if isinstance(obj, dict) and "error" in obj:
+        return f"error: {str(obj['error'])[:100]}"
+    if isinstance(obj, dict):
+        if name == "list_dir":
+            return _plural(len(obj.get("entries", [])), "entry", "entries")
+        if name in ("glob", "grep"):
+            return _plural(len(obj.get("matches", [])), "match", "matches")
+        if name == "web_search":
+            return _plural(len(obj.get("results", [])), "result", "results")
+        if name == "ast_symbols":
+            return _plural(len(obj.get("symbols", [])), "symbol", "symbols")
+        if name == "write_file":
+            return f"wrote {obj.get('bytes', 0)} bytes"
+        if name == "edit_file":
+            return "edited"
+        if name == "ast_replace_symbol":
+            return "replaced"
+        if name == "run_shell":
+            lines = (obj.get("stdout") or "").count("\n")
+            return f"rc {obj.get('return_code')} · {_plural(lines, 'line', 'lines')}"
+        if name == "run_code":
+            return f"rc {obj.get('exit_code')} · {obj.get('sandbox', '')}"
+        if name == "web_fetch":
+            title = (obj.get("title") or "").strip()
+            chars = len(obj.get("text") or "")
+            return f'"{title[:40]}" · {chars} chars' if title else f"{chars} chars"
+        if name == "ast_show_symbol":
+            return _plural((obj.get("source") or "").count("\n") + 1, "line", "lines")
+        if name == "analyze_image":
+            return f"{len(obj.get('description') or '')} chars"
+        return next(iter(obj)) if obj else "ok"
+    if name == "read_file":
+        return _plural(result.count("\n") + 1, "line", "lines") if result else "0 lines"
+    return " ".join(result.split())[:80]
+
+
+def _preview(args: dict) -> str:
+    try:
+        s = json.dumps(args)
+    except (TypeError, ValueError):
+        s = str(args)
+    return s[:80]
+
+
+def _outside_cwd(args: dict) -> bool:
+    p = args.get("file_path")
+    if not p:
+        return False
+    try:
+        Path(p).expanduser().resolve().relative_to(Path.cwd().resolve())
+        return False
+    except ValueError:
+        return True
+
+
+def _diff_preview(name: str, args: dict) -> str:
+    path = args.get("file_path", "")
+    try:
+        target = Path(path).expanduser().resolve()
+        old = target.read_text(encoding="utf-8") if target.is_file() else ""
+    except OSError:
+        old = ""
+    if name == "write_file":
+        new = args.get("content", "")
+        if args.get("content_b64"):
+            import base64
+
+            try:
+                new = base64.b64decode(args["content_b64"]).decode("utf-8", errors="replace")
+            except Exception:  # noqa: BLE001
+                new = "<base64 payload>"
+    else:
+        new = old.replace(args.get("old_string", ""), args.get("new_string", ""), 1)
+    diff = difflib.unified_diff(old.splitlines(), new.splitlines(), lineterm="", n=2)
+    text = "\n".join(list(diff)[:60])
+    return text or f"write {path}"
+
+
+def _describe(name: str, args: dict) -> tuple[str, str]:
+    if name == "run_shell":
+        cmd = args.get("command", "")
+        return (
+            f"run shell: {cmd[:60]}",
+            f"command: {cmd}\ncwd: {args.get('working_directory') or '.'}",
+        )
+    if name in _GATED_PATH_TOOLS:
+        return f"{name}: {args.get('file_path', '')}", _diff_preview(name, args)
+    return name, json.dumps(args)[:500]
+
+
+def _guardian_review_content(name: str, args: dict) -> str:
+    if name in _GATED_PATH_TOOLS:
+        return _diff_preview(name, args)
+    return (
+        f"Replace symbol '{args.get('name', '')}' in {args.get('file_path', '')} with:\n"
+        f"{(args.get('new_source') or '')[:4000]}"
+    )
+
+
+def guardian_review(guardian, content: str) -> str | None:
+    """Ask an independent model to review a code change/snippet. Returns a
+    one-line verdict ('safe', 'risky: ...', 'bug: ...') or None on failure."""
+    prompt = (
+        "You are an independent code reviewer giving a second opinion on a proposed "
+        "change. Reply with exactly one line: 'VERDICT: safe', 'VERDICT: risky: <reason>', "
+        f"or 'VERDICT: bug: <reason>'. Be terse.\n\nProposed change:\n{content}\n\nVerdict:"
+    )
+    messages = [{"role": "user", "content": prompt}]
+    msg = None
+    for _ in range(2):  # one retry: review runs against a sometimes-flaky API
+        try:
+            msg = guardian.chat(messages, [], 0.0, 512)
+            break
+        except Exception:  # noqa: BLE001 - review is best-effort
+            msg = None
+    if msg is None:
+        return None
+    text = (msg.get("content") or msg.get("reasoning_content") or "").strip()
+    for line in text.splitlines():
+        s = line.strip()
+        if s.upper().startswith("VERDICT:"):
+            return s.split(":", 1)[1].strip()
+    return text.splitlines()[0][:120] if text else None
+
+
+def verdict_severity(verdict: str | None) -> str:
+    """Classify a verdict string into safe | risky | bug | unknown."""
+    if not verdict:
+        return "unknown"
+    head = verdict.strip().lower()
+    if head.startswith("safe"):
+        return "safe"
+    if head.startswith("risky"):
+        return "risky"
+    if head.startswith("bug"):
+        return "bug"
+    return "unknown"
+
+
+def verdict_exit_code(verdict: str | None) -> int:
+    """Exit code for `review` as a PR gate: 0 safe, 1 risky, 2 bug, 0 unknown."""
+    return {"safe": 0, "risky": 1, "bug": 2, "unknown": 0}[verdict_severity(verdict)]
+
+
+def _guardian_verdict(guardian, name: str, args: dict) -> str | None:
+    return guardian_review(guardian, _guardian_review_content(name, args))
+
+
+def _approved(name, args, interactive, auto_approve, renderer, guardian=None) -> bool:
+    forced = name in _GATED_PATH_TOOLS and _outside_cwd(args)
+    if auto_approve and not forced:
+        return True
+    if not interactive:
+        return False
+    title, detail = _describe(name, args)
+    if guardian is not None and name in _EDIT_TOOLS:
+        verdict = _guardian_verdict(guardian, name, args)
+        if verdict:
+            detail = f"{detail}\n\nGuardian: {verdict}"
+    return renderer.confirm(title, detail)
+
+
+def _stream_turn(backend, messages, schemas, settings, renderer):
+    """Drive one streaming turn: stream content tokens live and capture the
+    assembled message (with any tool_calls) from the generator's return value."""
+    captured = {"msg": {"role": "assistant", "content": "", "tool_calls": None}}
+
+    def content_tokens():
+        gen = backend.stream_chat_tools(
+            messages, schemas, settings.temperature, settings.max_tokens
+        )
+        while True:
+            try:
+                channel, text = next(gen)
+            except StopIteration as stop:
+                captured["msg"] = stop.value
+                return
+            if channel == "content":
+                yield text
+
+    renderer.answer_stream(content_tokens())
+    return captured["msg"], True
+
+
+def run_agent(
+    backend,
+    registry,
+    messages,
+    settings,
+    renderer,
+    *,
+    interactive: bool,
+    auto_approve: bool,
+    max_steps: int | None = None,
+    stream: bool = False,
+    guardian=None,
+) -> str:
+    steps = max_steps if max_steps is not None else settings.max_steps
+    schemas = registry.schemas()
+    can_stream = stream and hasattr(backend, "stream_chat_tools")
+    for _ in range(steps):
+        if can_stream:
+            msg, streamed = _stream_turn(backend, messages, schemas, settings, renderer)
+        else:
+            msg = backend.chat(messages, schemas, settings.temperature, settings.max_tokens)
+            streamed = False
+        tool_calls = msg.get("tool_calls")
+        if not tool_calls:
+            content = msg.get("content") or ""
+            messages.append({"role": "assistant", "content": content})
+            if not streamed:
+                renderer.answer(content)
+            return content
+
+        messages.append(
+            {"role": "assistant", "content": msg.get("content"), "tool_calls": tool_calls}
+        )
+        for tc in tool_calls:
+            name = tc["function"]["name"]
+            args = _parse_args(tc["function"].get("arguments", ""))
+            meta = registry.get(name)
+            renderer.tool_start(name, _preview(args))
+            start = time.monotonic()
+            if meta is None:
+                result = json.dumps({"error": f"unknown tool: {name}"})
+            elif "__parse_error__" in args:
+                result = json.dumps({"error": "invalid JSON arguments"})
+            elif meta.dangerous and not _approved(
+                name, args, interactive, auto_approve, renderer, guardian
+            ):
+                result = json.dumps({"error": "denied by user"})
+            else:
+                try:
+                    result = registry.call(name, **coerce_args(meta.parameters, args))
+                except Exception as e:  # noqa: BLE001 - surface tool failure to model
+                    result = json.dumps({"error": f"{type(e).__name__}: {e}"})
+            result = str(result)[:_MAX_TOOL_RESULT]
+            ok = '"error"' not in result[:30]
+            renderer.tool_result(ok, _summarize_result(name, result), time.monotonic() - start)
+            messages.append({"role": "tool", "tool_call_id": tc["id"], "content": result})
+    return f"Reached the {steps}-step limit without a final answer."