deepparallel 0.5.3__tar.gz → 0.5.5__tar.gz

{deepparallel-0.5.3 → deepparallel-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.3
+Version: 0.5.5
 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.3 → deepparallel-0.5.5}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.5.3"
+__version__ = "0.5.5"

{deepparallel-0.5.3 → deepparallel-0.5.5}/deepparallel/agent.py

@@ -307,6 +307,7 @@ def run_agent(
     max_steps: int | None = None,
     stream: bool = False,
     guardian=None,
+    on_event=None,
 ) -> str:
     steps = max_steps if max_steps is not None else settings.max_steps
     schemas = registry.schemas()
@@ -354,6 +355,11 @@ def run_agent(
                 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]
+            if on_event is not None:
+                try:
+                    on_event(name, args, result)
+                except Exception:  # noqa: BLE001 - observation must never break the loop
+                    pass
             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})

{deepparallel-0.5.3 → deepparallel-0.5.5}/deepparallel/cli.py

@@ -16,6 +16,7 @@ apply to chat and run.
 
 from __future__ import annotations
 
+import os
 import sys
 from dataclasses import replace
 from pathlib import Path
@@ -53,6 +54,8 @@ from deepparallel.fusion import (
 )
 from deepparallel.renderer import PlainRenderer, Renderer, RichRenderer
 from deepparallel.tools import get_registry
+from deepparallel.cockpit import Cockpit
+from deepparallel.cockpit_observe import make_observer
 
 
 def _build_messages(history: list[tuple[str, str]], system: str, user_msg: str) -> list[dict]:
@@ -291,6 +294,13 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
     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 ""
@@ -305,7 +315,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 · /cockpit · /fast //fuse //escalate //deep · prompt"
             )
             continue
         if user_msg in {"/auto", "/yes"}:
@@ -333,6 +343,17 @@ 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
 
         messages.append({"role": "user", "content": user_msg})
         if deep_next:
@@ -350,12 +371,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()
 
 
@@ -486,6 +510,66 @@ def run(
         sys.exit(1)
 
 
+@main.command()
+@click.option("--yes", "-y", "assume_yes", is_flag=True, help="Auto-approve tool calls.")
+@click.argument("prompt", nargs=-1, required=True)
+@click.pass_context
+def cockpit(ctx: click.Context, assume_yes: bool, prompt: tuple[str, ...]) -> None:
+    """Run a task in cockpit mode: a live data window plus WaveTerm render blocks.
+
+    The terminal streams the agent while an adjacent block shows a live data
+    window (sources, citations, claims) and pages the agent reads open as web
+    blocks. Outside WaveTerm it runs normally and still logs the event stream.
+    """
+    settings = _apply_flags(ctx.obj["settings"], False, assume_yes)
+    backend = _require_ready(settings)
+    events_path = os.path.abspath(os.path.join(".cockpit", "events.jsonl"))
+    os.makedirs(os.path.dirname(events_path), exist_ok=True)
+    open(events_path, "w").close()
+    cp = Cockpit(events_path)
+    cp.status("start", "cockpit online")
+    cp.ensure_panel()
+    backend = _wrap_fusion(backend, settings)
+    system = load_system_prompt()
+    messages = _build_messages([], system, " ".join(prompt))
+    renderer = _make_renderer(force_plain=False, assume_yes=settings.auto_approve)
+    try:
+        run_agent(
+            backend,
+            get_registry(),
+            messages,
+            settings,
+            renderer,
+            interactive=True,
+            auto_approve=settings.auto_approve,
+            stream=True,
+            on_event=make_observer(cp),
+        )
+    except Exception as e:  # noqa: BLE001 - surface as friendly message
+        renderer.error(_translate_error(e))
+        failed = True
+    else:
+        failed = False
+    cp.status("done", "cockpit complete")
+    cp.notify("DeepParallel cockpit run complete")
+    if failed:
+        sys.exit(1)
+
+
+@main.command(name="_cockpit-panel", hidden=True)
+@click.argument("events_path")
+def _cockpit_panel(events_path: str) -> None:
+    """Internal: render the live cockpit data window for an events log."""
+    from deepparallel.cockpit_panel import run_panel
+
+    def _complete(state) -> bool:
+        # cli.cockpit emits status(phase="done", message="cockpit complete")
+        # at the end of a run; stop the panel so its process does not leak.
+        return "cockpit complete" in getattr(state, "status", "")
+
+    run_panel(events_path, stop_when=_complete)
+
+
 @main.command()
 @click.option("--diff", "as_diff", is_flag=True, help="Read a unified diff from stdin.")
 @click.argument("path", required=False)

deepparallel-0.5.5/deepparallel/cockpit.py

@@ -0,0 +1,163 @@
+# Copyright 2026, Crowe Logic Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""WaveTerm orchestration and event-log layer for the DeepParallel cockpit.
+
+The terminal (WaveTerm) is the control and DATA WINDOW; the agent spawns
+adjacent RENDER blocks (web, file preview) via WaveTerm's `wsh` CLI. Everything
+flows through ONE append-only event log: a `.jsonl` file, one JSON object per
+line, default `./.cockpit/events.jsonl`. Producers append; consumers tail.
+
+Event shape:
+  {"t": <float epoch seconds>, "type": <string>, "data": <object>}
+
+`Cockpit` is the single producer surface. `emit` appends a contract event line
+(creating the parent dir, never raising). `open_web` / `view_file` shell out to
+`wsh`, parse the "created block <id>" line, emit a matching "block" event, and
+return the block id. Off WaveTerm (env `WAVETERM` / `WAVETERM_BLOCKID` unset) or
+on any failure these block helpers are graceful no-ops returning None, while
+`emit` still records events so the log stays useful in plain terminals.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+# Bound every shell-out so a hung `wsh` can never stall the agent loop.
+_WSH_TIMEOUT_S = 5.0
+
+# `wsh web open` / `wsh view` print a line like "created block <blockid>".
+_BLOCK_RE = re.compile(r"created block\s+(\S+)", re.IGNORECASE)
+
+
+class Cockpit:
+    """Append-only event log plus WaveTerm `wsh` block orchestration.
+
+    Args:
+        events_path: path to the append-only `.jsonl` event log.
+    """
+
+    def __init__(self, events_path: str = ".cockpit/events.jsonl"):
+        self.events_path = Path(events_path)
+        self._panel_opened = False
+
+    # --- environment -------------------------------------------------------
+
+    def in_waveterm(self) -> bool:
+        """True when running inside a WaveTerm block (env signals present)."""
+        return bool(os.environ.get("WAVETERM") or os.environ.get("WAVETERM_BLOCKID"))
+
+    # --- event log ---------------------------------------------------------
+
+    def emit(self, type: str, **data: Any) -> None:
+        """Append one contract event line. Creates the parent dir. Never raises."""
+        event = {"t": time.time(), "type": type, "data": data}
+        try:
+            self.events_path.parent.mkdir(parents=True, exist_ok=True)
+            line = json.dumps(event, ensure_ascii=False, default=str)
+            with self.events_path.open("a", encoding="utf-8") as fh:
+                fh.write(line + "\n")
+        except Exception:
+            # The event log is best-effort; a failed write must not break the
+            # agent loop or any producer.
+            pass
+
+    # --- wsh block orchestration ------------------------------------------
+
+    def _run_wsh(self, args: list[str]) -> str | None:
+        """Run `wsh <args>` time-bounded; return stdout or None on any failure."""
+        if not self.in_waveterm():
+            return None
+        try:
+            proc = subprocess.run(
+                ["wsh", *args],
+                capture_output=True,
+                text=True,
+                timeout=_WSH_TIMEOUT_S,
+                check=False,
+            )
+        except Exception:
+            return None
+        if proc.returncode != 0:
+            return None
+        return proc.stdout
+
+    @staticmethod
+    def _parse_blockid(stdout: str | None) -> str | None:
+        """Extract the block id from a `wsh` "created block <id>" line."""
+        if not stdout:
+            return None
+        match = _BLOCK_RE.search(stdout)
+        return match.group(1) if match else None
+
+    def open_web(self, url: str) -> str | None:
+        """Open a WaveTerm web block for `url`; emit a "block" event; return id.
+
+        No-op returning None off WaveTerm or on any `wsh` failure.
+        """
+        blockid = self._parse_blockid(self._run_wsh(["web", "open", url]))
+        if blockid is not None:
+            self.emit("block", action="open", kind="web", target=url, blockid=blockid)
+        return blockid
+
+    def view_file(self, path: str) -> str | None:
+        """Open a WaveTerm preview block for `path`; emit a "block" event; return id.
+
+        No-op returning None off WaveTerm or on any `wsh` failure.
+        """
+        blockid = self._parse_blockid(self._run_wsh(["view", path]))
+        if blockid is not None:
+            self.emit("block", action="open", kind="file", target=path, blockid=blockid)
+        return blockid
+
+    def notify(self, message: str) -> None:
+        """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:
+        """Emit a "status" event."""
+        self.emit("status", phase=phase, message=message)
+
+    def source(self, url: str, title: str, provider: str) -> None:
+        """Emit a "source" event for a grounded source fetched."""
+        self.emit("source", url=url, title=title, provider=provider)
+
+    def citation(self, ref: int, url: str, title: str) -> None:
+        """Emit a "citation" event for a cited reference."""
+        self.emit("citation", ref=ref, url=url, title=title)
+
+    def claim(self, text: str, grounded: bool, confidence: float) -> None:
+        """Emit a "claim" event. Confidence is clamped to the 0..1 contract range."""
+        confidence = min(1.0, max(0.0, confidence))
+        self.emit("claim", text=text, grounded=grounded, confidence=confidence)
+
+    def sim(self, step: int, arm: str, metric: str, value: float) -> None:
+        """Emit a "sim" event for one A/B simulation datapoint."""
+        self.emit("sim", step=step, arm=arm, metric=metric, value=value)

deepparallel-0.5.5/deepparallel/cockpit_observe.py

@@ -0,0 +1,65 @@
+# Copyright 2026, Crowe Logic Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Translate agent tool results into cockpit events and render blocks.
+
+`make_observer(cockpit)` returns a callback the agent loop invokes after every
+tool call as `observe(name, args, result)`. It reads grounding tool results
+(web_search, web_fetch, mcp_search) and emits the matching contract events so
+the live data window updates, and opens the pages the agent reads as adjacent
+WaveTerm web blocks (capped, so a long run does not spawn dozens of blocks).
+Observation is best-effort: it never raises into the agent loop.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable
+
+_MAX_WEB_BLOCKS = 4  # cap render blocks opened from fetched pages
+
+
+def make_observer(cockpit) -> Callable[[str, dict, str], None]:
+    """Return an observe(name, args, result) callback bound to `cockpit`."""
+    counters = {"ref": 0, "blocks": 0}
+
+    def observe(name: str, args: dict, result: str) -> None:
+        try:
+            obj: Any = json.loads(result)
+        except (ValueError, TypeError):
+            obj = 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 results[:8]:
+                        url = r.get("url")
+                        if not url:
+                            continue
+                        counters["ref"] += 1
+                        cockpit.source(url=url, title=r.get("title", ""), provider=provider)
+                        cockpit.citation(ref=counters["ref"], url=url, title=r.get("title", ""))
+                    answer = obj.get("answer")
+                    if answer:
+                        cockpit.claim(text=str(answer)[:240], grounded=True, confidence=0.7)
+                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":
+                    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
+            pass
+
+    return observe