deepparallel 0.4.1__tar.gz → 0.4.2__tar.gz

{deepparallel-0.4.1 → deepparallel-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.4.1
+Version: 0.4.2
 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
@@ -115,7 +115,12 @@ compose hosted backends (no GPU/weight-merging), so they are API-call stacking.
 - 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`.
+  `ast_replace_symbol`, `run_shell`, `run_code`, `open_path` (open a file, folder,
+  or URL in the OS default app - e.g. an HTML report in the browser).
+
+In interactive chat, type `/auto` to toggle auto-approve (tools run without
+asking; edits outside the project and unknown dependencies still confirm), or
+start with `deepparallel --yes`.
 
 `web_search` needs `DEEPPARALLEL_SEARCH_API_KEY`; `analyze_image` works out of the
 box on a multimodal deployment (override with `DEEPPARALLEL_VISION_DEPLOYMENT`).

{deepparallel-0.4.1 → deepparallel-0.4.2}/README.md

@@ -91,7 +91,12 @@ compose hosted backends (no GPU/weight-merging), so they are API-call stacking.
 - 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`.
+  `ast_replace_symbol`, `run_shell`, `run_code`, `open_path` (open a file, folder,
+  or URL in the OS default app - e.g. an HTML report in the browser).
+
+In interactive chat, type `/auto` to toggle auto-approve (tools run without
+asking; edits outside the project and unknown dependencies still confirm), or
+start with `deepparallel --yes`.
 
 `web_search` needs `DEEPPARALLEL_SEARCH_API_KEY`; `analyze_image` works out of the
 box on a multimodal deployment (override with `DEEPPARALLEL_VISION_DEPLOYMENT`).

{deepparallel-0.4.1 → deepparallel-0.4.2}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"

{deepparallel-0.4.1 → deepparallel-0.4.2}/deepparallel/agent.py

@@ -71,6 +71,8 @@ def _summarize_result(name: str, result: str) -> str:
             return "edited"
         if name == "ast_replace_symbol":
             return "replaced"
+        if name == "open_path":
+            return f"opened {obj.get('opened', '')}" if "opened" in obj else "ok"
         if name == "run_shell":
             lines = (obj.get("stdout") or "").count("\n")
             return f"rc {obj.get('return_code')} · {_plural(lines, 'line', 'lines')}"

{deepparallel-0.4.1 → deepparallel-0.4.2}/deepparallel/cli.py

@@ -289,8 +289,10 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
     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
     while True:
-        tag = f"[{mode}] " if mode != "off" else ""
+        bits = ([mode] if mode != "off" else []) + (["auto"] if auto else [])
+        tag = f"[{' · '.join(bits)}] " if bits else ""
         try:
             user_msg = console.input(f"{tag}{branding.user_prefix()}› ").strip()
         except (EOFError, KeyboardInterrupt):
@@ -302,9 +304,19 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
             break
         if user_msg == "/help":
             branding.info(
-                "/quit · /reset · /info · /tools · /fast //fuse //escalate //deep · prompt"
+                "/quit · /reset · /info · /tools · /auto · /fast //fuse //escalate //deep · prompt"
             )
             continue
+        if user_msg in {"/auto", "/yes"}:
+            auto = not auto
+            if auto:
+                branding.info(
+                    "auto-approve ON - tools run without asking. Edits outside this "
+                    "project and unknown dependencies still confirm. /auto to turn off."
+                )
+            else:
+                branding.info("auto-approve OFF - mutating tools will ask first.")
+            continue
         if user_msg == "/reset":
             messages = [{"role": "system", "content": system}]
             branding.info("conversation cleared.")
@@ -334,7 +346,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
                 settings,
                 renderer,
                 interactive=True,
-                auto_approve=settings.auto_approve,
+                auto_approve=auto,
                 stream=True,
                 guardian=guardian,
             )
@@ -376,14 +388,19 @@ def _chat_loop(settings: Settings) -> None:
 )
 @click.version_option(__version__, prog_name="deepparallel")
 @click.option("--temperature", "-t", default=None, type=float, help="Sampling temperature.")
+@click.option(
+    "--yes", "-y", "assume_yes", is_flag=True, help="Auto-approve tool actions (toggle with /auto)."
+)
 @click.pass_context
-def main(ctx: click.Context, temperature: float | None) -> None:
+def main(ctx: click.Context, temperature: float | None, assume_yes: bool) -> None:
     """DeepParallel - a focused agentic CLI for the DeepParallel model."""
     load_dotenv()
     ctx.ensure_object(dict)
     settings = resolve_settings()
     if temperature is not None:
         settings = replace(settings, temperature=temperature)
+    if assume_yes:
+        settings = replace(settings, auto_approve=True)
     ctx.obj["settings"] = settings
     if ctx.invoked_subcommand is None:
         _chat_loop(settings)

{deepparallel-0.4.1 → deepparallel-0.4.2}/deepparallel/renderer.py

@@ -13,7 +13,6 @@ incrementally (no redrawing Live regions) so output never ghosts.
 from __future__ import annotations
 
 import sys
-import threading
 import time
 from abc import ABC, abstractmethod
 from typing import Iterable
@@ -132,8 +131,6 @@ class RichRenderer(Renderer):
         self._console = console or branding.console
         self._input_fn = input_fn or self._console.input
         self._cur: str | None = None
-        self._timer_stop: threading.Event | None = None
-        self._timer_thread: threading.Thread | None = None
 
     def welcome(self, backend_label, *, version="", tool_count=0, fusion_modes=()) -> None:
         animate = self._console.is_terminal and _REVEAL_SECONDS > 0
@@ -155,12 +152,14 @@ class RichRenderer(Renderer):
         self._console.print(branding.build_transcript_markdown(self._console, text))
 
     def answer_stream(self, chunks: Iterable[str]) -> str:
-        """Stream the answer. On a real terminal, render Markdown live in a panel
-        that grows as tokens arrive (headings, code, lists format in place); the
-        final frame is the same panel `answer()` would print, so there is no
-        double render. On a pipe / non-tty, fall back to raw inline streaming."""
+        """Stream the answer. On a real terminal, render Markdown block by block,
+        append-only: each complete block (a paragraph/heading/list ended by a
+        blank line, or a closed code fence) is rendered once as it settles. This
+        never moves the cursor up, so it cannot ghost or stack the way a growing
+        Live region does - it works the same on any terminal and at any answer
+        length. On a pipe / non-tty, fall back to raw inline streaming."""
         if self._console.is_terminal:
-            return self._stream_live_markdown(chunks)
+            return self._stream_markdown_blocks(chunks)
         return self._stream_inline(chunks)
 
     def _stream_inline(self, chunks: Iterable[str]) -> str:
@@ -185,71 +184,63 @@ class RichRenderer(Renderer):
             self._console.print()
         return "".join(parts)
 
-    def _stream_live_markdown(self, chunks: Iterable[str]) -> str:
-        from rich.live import Live
+    def _stream_markdown_blocks(self, chunks: Iterable[str]) -> str:
+        from rich.markdown import Markdown
+        from rich.padding import Padding
 
-        parts: list[str] = []
+        full: list[str] = []
+        buf = ""  # text not yet split into complete lines
+        block: list[str] = []  # lines of the block currently accumulating
+        in_fence = False
         started = False
-        last_draw = 0.0
-        live = Live(
-            console=self._console,
-            auto_refresh=False,  # we drive refreshes; deterministic, no bg thread
-            vertical_overflow="visible",  # let answers taller than the screen scroll
-        )
-        try:
-            for c in chunks:
-                parts.append(c)
-                if not started:
-                    if not "".join(parts).strip():
-                        continue  # hold the panel back until real content arrives
-                    started = True
-                    live.start()
-                now = time.monotonic()
-                if now - last_draw >= 0.06:  # throttle to ~16 fps
-                    live.update(self._answer_panel("".join(parts)), refresh=True)
-                    last_draw = now
-            if started:  # final frame: the complete, settled answer
-                live.update(self._answer_panel("".join(parts)), refresh=True)
-        finally:
-            if started:
-                live.stop()
-        return "".join(parts)
 
-    def _answer_panel(self, text: str):
-        return branding.build_transcript_markdown(self._console, _balance_fences(text))
+        def emit() -> None:
+            nonlocal block, started
+            text = "\n".join(block).strip("\n")
+            block = []
+            if not text.strip():
+                return
+            if not started:
+                started = True
+                self._console.print(f"[{branding.DP_ACCENT}]{branding.MARK}[/]", highlight=False)
+            self._console.print(
+                Padding(Markdown(_balance_fences(text)), (0, 0, 0, branding.GUTTER))
+            )
+
+        for c in chunks:
+            full.append(c)
+            buf += c
+            while "\n" in buf:  # only act on complete lines; keep the partial
+                line, buf = buf.split("\n", 1)
+                if line.strip().startswith("```"):
+                    block.append(line)
+                    if in_fence:  # this line closes the fence -> block is complete
+                        in_fence = False
+                        emit()
+                    else:
+                        in_fence = True
+                elif in_fence:
+                    block.append(line)
+                elif line.strip() == "":  # blank line ends a prose block
+                    emit()
+                else:
+                    block.append(line)
+        if buf.strip():  # trailing partial line at end of stream
+            block.append(buf)
+        emit()  # flush whatever block remains (fence balanced if still open)
+        return "".join(full)
 
     def reasoning(self, text: str) -> None:
         self._console.print(branding.build_reasoning_panel(self._console, text))
 
     def tool_start(self, name: str, args_preview: str) -> None:
+        # Append-only: render the running card and stop. A per-tick elapsed timer
+        # needs carriage-return overwrites, which some terminals don't honor and
+        # then flood with hundreds of lines; the final card carries the duration.
         self._cur = name
         branding.render_tool_card(self._console, name, args_preview, status="running")
-        if self._console.is_terminal:
-            self._timer_stop = threading.Event()
-            start = time.monotonic()
-            fh = self._console.file
-
-            def tick() -> None:
-                while not self._timer_stop.wait(0.5):  # type: ignore[union-attr]
-                    fh.write(f"\r  {name}... {time.monotonic() - start:.0f}s ")
-                    fh.flush()
-
-            self._timer_thread = threading.Thread(target=tick, daemon=True)
-            self._timer_thread.start()
-
-    def _stop_timer(self) -> None:
-        if self._timer_stop is None:
-            return
-        self._timer_stop.set()
-        if self._timer_thread is not None:
-            self._timer_thread.join(timeout=1.0)
-        self._timer_stop = None
-        self._timer_thread = None
-        self._console.file.write("\r" + " " * 48 + "\r")  # clear the timer line
-        self._console.file.flush()
 
     def tool_result(self, ok: bool, summary: str, duration_s: float) -> None:
-        self._stop_timer()
         branding.render_tool_card(
             self._console,
             self._cur or "",

deepparallel-0.4.2/deepparallel/system_prompt.txt

@@ -0,0 +1,4 @@
+You are DeepParallel, a precise and capable coding assistant served via Crowe Logic.
+Answer clearly and directly. When a problem benefits from step-by-step reasoning, reason carefully before giving the final answer. Be concise unless asked for depth.
+
+You can use tools to read, search, analyze, edit, open, and run code. Use them when they help; do not call them speculatively. When the user asks to "open" a file (an HTML report, image, PDF, or folder) for viewing, use open_path to launch it in the default app rather than read_file, which only returns text contents. When asked to run something with different parameters, prefer non-destructive approaches (command-line arguments, environment variables, or a temporary copy) over editing the user's source files. Only edit a source file when changing that file is the actual goal, and explain what you changed.

deepparallel-0.4.2/deepparallel/tools/shell.py

@@ -0,0 +1,69 @@
+"""Shell execution tools."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+
+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}
+    )
+
+
+def _opener_argv(path: str) -> list[str]:
+    if sys.platform == "darwin":
+        return ["open", path]
+    if sys.platform.startswith("win"):
+        return ["cmd", "/c", "start", "", path]
+    return ["xdg-open", path]
+
+
+@tool(dangerous=True)
+def open_path(path: str) -> str:
+    """Open a file, directory, or URL in the operating system's default app.
+
+    Use this when the user asks to "open" something for viewing - an HTML report
+    in the browser, a PNG/PDF in the image/document viewer, a folder in the file
+    manager. This launches the real app; it does not return the file contents
+    (use read_file for text or analyze_image to inspect an image).
+
+    :param path: File path, directory, or URL to open.
+    """
+    argv = _opener_argv(path)
+    if shutil.which(argv[0]) is None:
+        return json.dumps({"error": f"no opener available ({argv[0]} not found)"})
+    try:
+        subprocess.Popen(argv, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except Exception as e:  # noqa: BLE001 - surface launch failure to the model
+        return json.dumps({"error": f"{type(e).__name__}: {e}"})
+    return json.dumps({"opened": path})

{deepparallel-0.4.1 → deepparallel-0.4.2}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.4.1
+Version: 0.4.2
 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
@@ -115,7 +115,12 @@ compose hosted backends (no GPU/weight-merging), so they are API-call stacking.
 - 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`.
+  `ast_replace_symbol`, `run_shell`, `run_code`, `open_path` (open a file, folder,
+  or URL in the OS default app - e.g. an HTML report in the browser).
+
+In interactive chat, type `/auto` to toggle auto-approve (tools run without
+asking; edits outside the project and unknown dependencies still confirm), or
+start with `deepparallel --yes`.
 
 `web_search` needs `DEEPPARALLEL_SEARCH_API_KEY`; `analyze_image` works out of the
 box on a multimodal deployment (override with `DEEPPARALLEL_VISION_DEPLOYMENT`).

{deepparallel-0.4.1 → deepparallel-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.4.1"
+version = "0.4.2"
 description = "DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic."
 readme = "README.md"
 license = { text = "Apache-2.0" }

{deepparallel-0.4.1 → deepparallel-0.4.2}/tests/test_renderer.py

@@ -95,7 +95,8 @@ def test_rich_tool_timer_path_renders_card(monkeypatch):
     out = buf.getvalue()
     assert "run_shell" in out
     assert "✓" in out and "rc 0" in out
-    assert r._timer_thread is None  # timer cleaned up
+    # append-only: no ticking timer thread is spawned
+    assert not hasattr(r, "_timer_thread")
 
 
 def test_rich_error_uses_cross():
@@ -123,15 +124,28 @@ def test_rich_confirm_shows_detail():
     assert "added line" in out
 
 
-def test_rich_answer_stream_returns_text_and_renders_live_markdown():
+def test_rich_answer_stream_returns_text_and_renders_markdown():
     buf = io.StringIO()
     con = Console(no_color=True, width=80, file=buf, force_terminal=True, highlight=False)
     r = RichRenderer(console=con)
     full = r.answer_stream(iter(["Hel", "lo ", "world"]))
     out = buf.getvalue()
     assert full == "Hello world"  # full text preserved for history
-    assert "Hello world" in out  # rendered in the live answer panel
-    assert "◆" in out and "answer" in out  # panel marker + title
+    assert "Hello world" in out  # rendered as a markdown block
+    assert "◆" in out  # answer marker printed once
+
+
+def test_rich_answer_stream_code_block_renders_atomically():
+    # a code block with an internal blank line must not be split mid-block
+    buf = io.StringIO()
+    con = Console(no_color=True, width=80, file=buf, force_terminal=True, highlight=False)
+    r = RichRenderer(console=con)
+    code = "intro\n\n```python\na = 1\n\nb = 2\n```\n\ndone"
+    full = r.answer_stream(iter([code]))
+    out = buf.getvalue()
+    assert full == code
+    assert "a = 1" in out and "b = 2" in out and "intro" in out and "done" in out
+    assert "```" not in out  # fence rendered, not shown literally
 
 
 def test_rich_answer_stream_renders_markdown_formatting():

deepparallel-0.4.2/tests/test_tools_shell.py

@@ -0,0 +1,48 @@
+import json
+
+import deepparallel.tools.shell as shell_mod
+from deepparallel.tools import get_registry
+
+
+def test_run_shell_captures_stdout_and_rc():
+    out = json.loads(shell_mod.run_shell("echo hello"))
+    assert out["return_code"] == 0
+    assert "hello" in out["stdout"]
+
+
+def test_run_shell_respects_cwd(tmp_path):
+    out = json.loads(shell_mod.run_shell("pwd", working_directory=str(tmp_path)))
+    assert str(tmp_path) in out["stdout"]
+
+
+def test_run_shell_timeout_returns_error():
+    out = json.loads(shell_mod.run_shell("sleep 5", timeout_seconds=1))
+    assert "timed out" in out["error"]
+
+
+def test_run_shell_is_dangerous():
+    assert get_registry().get("run_shell").dangerous is True
+
+
+def test_open_path_launches_default_opener(monkeypatch):
+    calls = {}
+    monkeypatch.setattr(shell_mod.shutil, "which", lambda _: "/usr/bin/open")
+
+    def fake_popen(argv, **kw):
+        calls["argv"] = argv
+        return object()
+
+    monkeypatch.setattr(shell_mod.subprocess, "Popen", fake_popen)
+    out = json.loads(shell_mod.open_path("/tmp/report.html"))
+    assert out["opened"] == "/tmp/report.html"
+    assert "/tmp/report.html" in calls["argv"]
+
+
+def test_open_path_reports_missing_opener(monkeypatch):
+    monkeypatch.setattr(shell_mod.shutil, "which", lambda _: None)
+    out = json.loads(shell_mod.open_path("/tmp/x.png"))
+    assert "error" in out
+
+
+def test_open_path_is_dangerous():
+    assert get_registry().get("open_path").dangerous is True

deepparallel-0.4.1/deepparallel/system_prompt.txt

@@ -1,4 +0,0 @@
-You are DeepParallel, a precise and capable coding assistant served via Crowe Logic.
-Answer clearly and directly. When a problem benefits from step-by-step reasoning, reason carefully before giving the final answer. Be concise unless asked for depth.
-
-You can use tools to read, search, analyze, edit, and run code. Use them when they help; do not call them speculatively. When asked to run something with different parameters, prefer non-destructive approaches (command-line arguments, environment variables, or a temporary copy) over editing the user's source files. Only edit a source file when changing that file is the actual goal, and explain what you changed.

deepparallel-0.4.1/deepparallel/tools/shell.py

@@ -1,38 +0,0 @@
-"""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-0.4.1/tests/test_tools_shell.py

@@ -1,24 +0,0 @@
-import json
-
-import deepparallel.tools.shell as shell_mod
-from deepparallel.tools import get_registry
-
-
-def test_run_shell_captures_stdout_and_rc():
-    out = json.loads(shell_mod.run_shell("echo hello"))
-    assert out["return_code"] == 0
-    assert "hello" in out["stdout"]
-
-
-def test_run_shell_respects_cwd(tmp_path):
-    out = json.loads(shell_mod.run_shell("pwd", working_directory=str(tmp_path)))
-    assert str(tmp_path) in out["stdout"]
-
-
-def test_run_shell_timeout_returns_error():
-    out = json.loads(shell_mod.run_shell("sleep 5", timeout_seconds=1))
-    assert "timed out" in out["error"]
-
-
-def test_run_shell_is_dangerous():
-    assert get_registry().get("run_shell").dangerous is True