deepparallel 0.4.1__tar.gz → 0.4.3__tar.gz

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

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

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

{deepparallel-0.4.1 → deepparallel-0.4.3}/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.3}/deepparallel/branding.py

@@ -9,6 +9,8 @@ status colors follow the Crowe Logic CLI family patterns.
 
 from __future__ import annotations
 
+import math
+
 from rich import box
 from rich.console import Console, Group
 from rich.markdown import Markdown
@@ -66,6 +68,91 @@ def thinking(text: str) -> None:
     console.print(f"[{DIM}]{text}[/]", end="", soft_wrap=True, highlight=False)
 
 
+_PULSE_BLOCKS = "▁▂▃▄▅▆▇█"
+
+# Crest color drifts slowly through these stops while the pulse travels. On-brand:
+# DeepParallel cyan -> a cooler teal-blue -> Crowe green, then loops. The drift is
+# what makes the spinner "change colors" as it works, distinct from the per-lane
+# brightness that creates the travelling crest.
+_CREST_PALETTE = ("#3fd0d0", "#5fb8c4", "#8fa4bf", "#79bf94", "#6fbf73")
+
+
+def _lerp_hex(a: str, b: str, t: float) -> str:
+    """Linear blend between two #rrggbb colors; t in 0..1. Pure, for the crest drift."""
+    t = 0.0 if t < 0 else 1.0 if t > 1 else t
+    ar, ag, ab = int(a[1:3], 16), int(a[3:5], 16), int(a[5:7], 16)
+    br, bg, bb = int(b[1:3], 16), int(b[3:5], 16), int(b[5:7], 16)
+    r = round(ar + (br - ar) * t)
+    g = round(ag + (bg - ag) * t)
+    bl = round(ab + (bb - ab) * t)
+    return f"#{r:02x}{g:02x}{bl:02x}"
+
+
+def _crest_color(phase: float) -> str:
+    """The crest hue at a continuous phase, cycling smoothly around _CREST_PALETTE."""
+    n = len(_CREST_PALETTE)
+    pos = (phase % n + n) % n  # wrap into 0..n
+    i = int(pos)
+    return _lerp_hex(_CREST_PALETTE[i], _CREST_PALETTE[(i + 1) % n], pos - i)
+
+
+class ThinkingSpinner:
+    """The 'working' animation in DeepParallel's idiom: several reasoning lanes
+    pulsing in parallel with a bright crest travelling across them, anchored by
+    the ◆ mark - parallel chains computing toward one answer, in the cyan
+    identity. Distinct from a borrowed braille dot.
+
+    Stateful: each render advances one frame. A rich `Live` widget animates it
+    simply by re-rendering at its refresh rate (the same mechanism the built-in
+    Spinner relies on), so no timer thread of our own is needed.
+    """
+
+    def __init__(
+        self,
+        label: str = "thinking",
+        *,
+        lanes: int = 5,
+        speed: float = 0.45,
+        spread: float = 0.7,
+        hue_speed: float = 0.06,
+    ):
+        self._label = label
+        self._lanes = lanes
+        self._speed = speed  # radians advanced per frame (animation tempo)
+        self._spread = spread  # phase offset between lanes (crest travel)
+        self._hue_speed = hue_speed  # palette stops advanced per frame (color drift)
+        self._tick = 0
+
+    def frame(self, tick: int) -> Text:
+        """Build the frame at a given tick (pure; used for rendering + tests)."""
+        text = Text()
+        crest = _crest_color(tick * self._hue_speed)  # this frame's drifting hue
+        text.append(f"{MARK} ", style=f"bold {crest}")
+        for i in range(self._lanes):
+            level = (math.sin(tick * self._speed - i * self._spread) + 1) / 2  # 0..1
+            # Crest cells take the live hue; mid cells a dimmed blend; troughs go dim.
+            if level > 0.72:
+                style = f"bold {crest}"
+            elif level > 0.4:
+                style = _lerp_hex("#3a4a4a", crest, 0.6)
+            else:
+                style = DIM
+            text.append(_PULSE_BLOCKS[round(level * (len(_PULSE_BLOCKS) - 1))], style=style)
+        text.append(f"  {self._label}…", style=DIM)
+        return text
+
+    def __rich__(self) -> Text:
+        frame = self.frame(self._tick)
+        self._tick += 1
+        return frame
+
+
+def thinking_spinner(label: str = "thinking") -> ThinkingSpinner:
+    """A fresh DeepParallel thinking animation (one per turn so it starts at
+    frame 0). Drive it inside a transient `rich.live.Live`."""
+    return ThinkingSpinner(label)
+
+
 def info(msg: str) -> None:
     console.print(f"[{DIM}]{msg}[/]")
 
@@ -179,6 +266,17 @@ def wordmark_lines() -> list[str]:
     return _WORDMARK.split("\n")
 
 
+def wordmark_width() -> int:
+    """Column width of the block wordmark; below this it wraps and shatters."""
+    return max((len(line) for line in wordmark_lines()), default=0)
+
+
+def compact_wordmark() -> str:
+    """A one-line banner for panes too narrow for the block wordmark. Rich
+    markup; always fits, so a split/narrow pane never shows shattered letters."""
+    return f"[bold {DP_ACCENT}]{MARK} DeepParallel[/]"
+
+
 def status_text(
     *, version: str, tool_count: int, fusion_modes: tuple[str, ...], backend_label: str
 ):

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

@@ -35,6 +35,7 @@ from deepparallel.agent import (
 )
 from deepparallel.backend import Backend, backend_for_deployment, resolve_backend
 from deepparallel.branding import console
+from deepparallel.userinput import read_user_input
 from deepparallel.config import (
     Settings,
     _bool_env,
@@ -233,7 +234,7 @@ def _stream_repl(backend: Backend, settings: Settings) -> None:
     history: list[tuple[str, str]] = []
     while True:
         try:
-            user_msg = console.input(branding.user_prefix() + "› ").strip()
+            user_msg = read_user_input()
         except (EOFError, KeyboardInterrupt):
             console.print()
             break
@@ -289,10 +290,12 @@ 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()
+            user_msg = read_user_input(tag)
         except (EOFError, KeyboardInterrupt):
             console.print()
             break
@@ -302,9 +305,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 +347,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 +389,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)
@@ -504,6 +522,22 @@ def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
     sys.exit(verdict_exit_code(verdict))
 
 
+@main.command()
+@click.option("--host", default="127.0.0.1", help="Bind host.")
+@click.option("--port", default=8013, type=int, help="Bind port.")
+def serve(host: str, port: int) -> None:
+    """Run the OpenAI-compatible gateway for Crowe Terminal / Crowe Code, etc.
+
+    Exposes /v1/chat/completions + /v1/models so any OpenAI-format client can use
+    the Crowe Logic model stack through one endpoint, with the Crowe Logic persona
+    injected and raw-model identity leaks scrubbed. Select a model by deployment
+    name (see /v1/models); fusion models plug in here later.
+    """
+    from deepparallel.serve import run_server
+
+    run_server(host, port)
+
+
 @main.command()
 @click.argument("path", required=True)
 @click.pass_context

{deepparallel-0.4.1 → deepparallel-0.4.3}/deepparallel/licensing.py

@@ -26,7 +26,7 @@ from pathlib import Path
 
 # Issuer public key (Ed25519, raw, base64). The matching private key is the
 # issuance secret and is never shipped.
-_EMBEDDED_PUBKEY = "I0YYNFwGGUZGD6h15leBEPBQ197Snik+njzxkVf/Owg="
+_EMBEDDED_PUBKEY = "BdxSRIB5F2K2bXf7c0UqsR6jC/cSRMSxojpzRpTCUQg="
 
 # Paid features -> minimum tier required.
 _FEATURE_TIER: dict[str, "Tier"] = {}

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

@@ -13,10 +13,9 @@ 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
+from typing import Iterable, Iterator
 
 from rich.console import Console
 
@@ -132,15 +131,18 @@ 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
-        for line in branding.wordmark_lines():
-            self._console.print(f"[{branding.DP_ACCENT}]{line}[/]", highlight=False)
-            if animate:
-                time.sleep(_REVEAL_SECONDS)
+        if self._console.width < branding.wordmark_width():
+            # Narrow / split pane: the block wordmark would wrap mid-letter and
+            # shatter. Use a compact one-line mark that always fits.
+            self._console.print(branding.compact_wordmark(), highlight=False)
+        else:
+            for line in branding.wordmark_lines():
+                self._console.print(f"[{branding.DP_ACCENT}]{line}[/]", highlight=False)
+                if animate:
+                    time.sleep(_REVEAL_SECONDS)
         self._console.print()
         self._console.print(
             branding.status_text(
@@ -155,14 +157,39 @@ 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."""
+        chunks = self._spin_until_first(chunks)
         if self._console.is_terminal:
-            return self._stream_live_markdown(chunks)
+            return self._stream_markdown_blocks(chunks)
         return self._stream_inline(chunks)
 
+    def _spin_until_first(self, chunks: Iterable[str]) -> Iterator[str]:
+        """Show a transient 'thinking' spinner during the wait for the first
+        token, then yield the stream through unchanged. The spinner is stopped
+        and cleared (transient=True) before any answer text prints, so unlike a
+        growing Live region it can never overlap or stack with the answer."""
+        it = iter(chunks)
+        if not self._console.is_terminal:
+            yield from it
+            return
+        from rich.live import Live
+
+        spinner = branding.thinking_spinner()
+        first = None
+        with Live(spinner, console=self._console, transient=True, refresh_per_second=12):
+            for c in it:
+                first = c
+                break
+        if first is None:
+            return  # empty stream (e.g. a tool-only turn): nothing to reveal
+        yield first
+        yield from it
+
     def _stream_inline(self, chunks: Iterable[str]) -> str:
         # Raw token streaming for pipes / non-tty: no Live, never ghosts. The
         # marker is printed only on the first VISIBLE character, so empty /
@@ -185,71 +212,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 "",