deepparallel 0.4.2__tar.gz → 0.4.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.4.2
+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

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

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

{deepparallel-0.4.2 → 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.2 → 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
@@ -294,7 +295,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
         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
@@ -521,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.2 → 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.2 → deepparallel-0.4.3}/deepparallel/renderer.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 import sys
 import time
 from abc import ABC, abstractmethod
-from typing import Iterable
+from typing import Iterable, Iterator
 
 from rich.console import Console
 
@@ -134,10 +134,15 @@ class RichRenderer(Renderer):
 
     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(
@@ -158,10 +163,33 @@ class RichRenderer(Renderer):
         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_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 /

deepparallel-0.4.3/deepparallel/serve.py

@@ -0,0 +1,261 @@
+# Copyright 2026, Crowe Logic Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""OpenAI-compatible gateway for DeepParallel.
+
+`deepparallel serve` exposes /v1/chat/completions and /v1/models so any
+OpenAI-format client (Crowe Terminal / Crowe Code, the Vercel AI SDK, etc.) can
+talk to the Crowe Logic model stack through one endpoint. The gateway is where
+the models are made to *act as Crowe Logic*:
+
+  * persona — a Crowe Logic system prompt is injected when the caller sends none;
+  * scrub  — raw-model identity leaks ("DeepSeek", deployment names) are rewritten
+             to CroweLM / Crowe Logic in the streamed output.
+
+v1 is passthrough: `model` selects an Azure deployment by name and we proxy its
+stream. Fusion models (deepparallel-deep / -reason) plug in here later by routing
+to the fusion stack instead of a single deployment — the wire contract and the
+persona/scrub layer stay identical, so the IDE never has to change.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from deepparallel.backend import backend_for_deployment
+from deepparallel.config import load_system_prompt, resolve_settings
+
+# Identity-leak scrub: the raw model occasionally self-identifies as DeepSeek
+# despite the persona prompt. Rewrite those surfaces so the assistant reads as
+# Crowe Logic. Order matters — specific deployment names before the bare brand.
+_SCRUB: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"DeepSeek[-\s]?V4[-\s]?Pro", re.I), "CroweLM Apex"),
+    (re.compile(r"DeepSeek[-\s]?V4[-\s]?Flash", re.I), "CroweLM Flash"),
+    (re.compile(r"DeepSeek[-\s]?R1[-\w]*", re.I), "CroweLM Reason"),
+    (re.compile(r"\bDeepSeek\b", re.I), "CroweLM"),
+]
+
+
+# Public model ids (what the IDE shows / sends) -> Azure deployment (internal).
+# The listing must never leak raw deployment names; chat accepts either the
+# alias or the raw name, so existing callers keep working.
+_MODEL_ALIASES: dict[str, str] = {
+    "crowelm-apex": "DeepSeek-V4-Pro",
+    "crowelm-reason": "DeepSeek-R1-0528",
+    "crowelm-flash": "DeepSeek-V4-Flash",
+}
+
+
+def _resolve_deployment(model: str, settings) -> str:
+    """Map a public model id to its Azure deployment, passing through raw names."""
+    return _MODEL_ALIASES.get(model, model or settings.deployment)
+
+
+def scrub(text: str) -> str:
+    """Rewrite raw-model identity leaks to the Crowe Logic brand."""
+    if not text:
+        return text
+    for pattern, repl in _SCRUB:
+        text = pattern.sub(repl, text)
+    return text
+
+
+def collapse_spacing(text: str) -> str:
+    """Collapse runs of 3+ newlines to a single blank line, and trim trailing
+    spaces before a newline. Raw models often over-emit blank lines, which reads
+    as double-spaced output in the chat; this normalizes it on the way out."""
+    text = re.sub(r"[ \t]+\n", "\n", text)
+    return re.sub(r"\n{3,}", "\n\n", text)
+
+
+class _ContentShaper:
+    """Smooths streamed content delivery. It (1) re-chunks token bursts to word
+    boundaries so the client renders a steady word-by-word reveal, and (2)
+    collapses blank-line runs across chunk boundaries (spacing). Holds back only
+    the trailing partial word until the next chunk; flush() drains the rest."""
+
+    def __init__(self):
+        self._buf = ""
+
+    def feed(self, text: str) -> list[str]:
+        self._buf += text
+        boundary = max(self._buf.rfind(" "), self._buf.rfind("\n"))
+        if boundary == -1:
+            return []  # no complete word yet — keep buffering
+        ready, self._buf = self._buf[: boundary + 1], self._buf[boundary + 1 :]
+        return self._tokens(ready)
+
+    def flush(self) -> list[str]:
+        ready, self._buf = self._buf, ""
+        return self._tokens(ready)
+
+    def _tokens(self, ready: str) -> list[str]:
+        ready = collapse_spacing(ready)
+        return re.findall(r"\S+\s*|\s+", ready) if ready else []
+
+
+def _ensure_persona(messages: list[dict]) -> list[dict]:
+    """Inject the Crowe Logic persona as a system message when none is present,
+    so a bare client request still answers in-brand."""
+    if any(m.get("role") == "system" for m in messages):
+        return messages
+    return [{"role": "system", "content": load_system_prompt()}, *messages]
+
+
+def _models_payload(settings) -> dict:
+    deployments = set(settings.parallel_deployments or (settings.deployment,))
+    aliased = set(_MODEL_ALIASES.values())
+    # Prefer branded aliases; never list a raw deployment name that has one.
+    ids = [pub for pub, dep in _MODEL_ALIASES.items() if dep in deployments]
+    ids += [dep for dep in deployments if dep not in aliased]
+    created = int(time.time())
+    return {
+        "object": "list",
+        "data": [
+            {"id": i, "object": "model", "created": created, "owned_by": "crowe-logic"} for i in ids
+        ],
+    }
+
+
+def _chunk(
+    model: str,
+    *,
+    content: str | None = None,
+    reasoning: str | None = None,
+    finish: str | None = None,
+) -> str:
+    delta: dict = {}
+    if content is not None:
+        delta["content"] = content
+    if reasoning is not None:
+        # reasoning_content is the OpenAI/Azure convention the chat clients read
+        # into their "thinking" channel — so the reasoning shows in the IDE.
+        delta["reasoning_content"] = reasoning
+    body = {
+        "id": "dp-" + str(int(time.time() * 1000)),
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
+    }
+    return "data: " + json.dumps(body) + "\n\n"
+
+
+def _make_handler(settings):
+    class Handler(BaseHTTPRequestHandler):
+        protocol_version = "HTTP/1.1"
+
+        def log_message(self, *_args):  # quiet default logging
+            pass
+
+        def _json(self, code: int, obj: dict) -> None:
+            payload = json.dumps(obj).encode()
+            self.send_response(code)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(payload)))
+            self.end_headers()
+            self.wfile.write(payload)
+
+        def do_GET(self):
+            if self.path.rstrip("/") == "/v1/models":
+                self._json(200, _models_payload(settings))
+                return
+            if self.path.rstrip("/") in ("/health", "/healthz"):
+                self._json(200, {"status": "ok"})
+                return
+            self._json(404, {"error": {"message": "not found"}})
+
+        def do_POST(self):
+            if self.path.rstrip("/") != "/v1/chat/completions":
+                self._json(404, {"error": {"message": "not found"}})
+                return
+            length = int(self.headers.get("Content-Length", 0))
+            try:
+                req = json.loads(self.rfile.read(length) or b"{}")
+            except json.JSONDecodeError:
+                self._json(400, {"error": {"message": "invalid JSON body"}})
+                return
+
+            model = req.get("model") or "crowelm-apex"
+            deployment = _resolve_deployment(model, settings)
+            messages = _ensure_persona(list(req.get("messages", [])))
+            temperature = req.get("temperature", 0.7)
+            max_tokens = req.get("max_tokens", 4096)
+            backend = backend_for_deployment(settings, deployment)
+
+            if req.get("stream"):
+                self._stream(backend, model, messages, temperature, max_tokens)
+            else:
+                self._complete(backend, model, messages, temperature, max_tokens)
+
+        def _stream(self, backend, model, messages, temperature, max_tokens):
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream")
+            self.send_header("Cache-Control", "no-cache")
+            self.send_header("Connection", "keep-alive")
+            self.end_headers()
+            shaper = _ContentShaper()
+            try:
+                for channel, text in backend.stream_chat(messages, temperature, max_tokens):
+                    if channel == "thinking":
+                        # reasoning passes through verbatim (scrubbed) so the IDE
+                        # can render the trace as it arrives.
+                        self._send(_chunk(model, reasoning=scrub(text)))
+                        continue
+                    for word in shaper.feed(scrub(text)):
+                        self._send(_chunk(model, content=word))
+                for word in shaper.flush():
+                    self._send(_chunk(model, content=word))
+                self._send(_chunk(model, finish="stop"))
+                self.wfile.write(b"data: [DONE]\n\n")
+                self.wfile.flush()
+            except BrokenPipeError:
+                pass  # client disconnected mid-stream
+
+        def _send(self, frame: str) -> None:
+            self.wfile.write(frame.encode())
+            self.wfile.flush()
+
+        def _complete(self, backend, model, messages, temperature, max_tokens):
+            # backend.chat returns the assistant message dict directly
+            # ({"role","content",...}), not a wrapper.
+            result = backend.chat(messages, None, temperature, max_tokens)
+            content = (
+                collapse_spacing(scrub((result or {}).get("content") or ""))
+                if isinstance(result, dict)
+                else ""
+            )
+            self._json(
+                200,
+                {
+                    "id": "dp-" + str(int(time.time() * 1000)),
+                    "object": "chat.completion",
+                    "created": int(time.time()),
+                    "model": model,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "message": {"role": "assistant", "content": content},
+                            "finish_reason": "stop",
+                        }
+                    ],
+                },
+            )
+
+    return Handler
+
+
+def run_server(host: str = "127.0.0.1", port: int = 8013) -> None:
+    settings = resolve_settings()
+    httpd = ThreadingHTTPServer((host, port), _make_handler(settings))
+    print(
+        f"DeepParallel gateway on http://{host}:{port}/v1  (model: {settings.deployment}, backend: {settings.backend})"
+    )
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\nshutting down")
+        httpd.shutdown()

deepparallel-0.4.3/deepparallel/system_prompt.txt

@@ -0,0 +1,7 @@
+You are DeepParallel, a precise coding assistant from Crowe Logic.
+
+Voice: direct and concise. Lead with the answer, not a preamble — never open with "I'd be happy to", "Great question", or by restating the request. Give depth only when asked or when the problem genuinely needs it. Stop when the answer is complete; don't pad with summaries or follow-up offers unless they add real value.
+
+Formatting: clean Markdown. Single blank lines between paragraphs — never double. Fenced code blocks with a language tag for code, inline backticks for identifiers and paths, tight lists (no blank line between items). Prefer a short prose answer over a bulleted list when a sentence will do.
+
+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. When asked to run something with different parameters, prefer non-destructive approaches (CLI arguments, environment variables, or a temporary copy) over editing the user's source files. Only edit a source file when changing it is the actual goal, and explain what you changed.

deepparallel-0.4.3/deepparallel/userinput.py

@@ -0,0 +1,61 @@
+"""Interactive prompt input.
+
+The REPL reads user turns through prompt_toolkit rather than the cooked
+`input()` / `console.input()` line discipline. This matters for robustness:
+`input()` reads whatever lands in the terminal's line buffer, so when another
+process writes to the same TTY (a background agent, a split pane), that stray
+output gets echoed into the buffer and read as if the user typed it - the REPL
+then "answers" the noise. prompt_toolkit puts the terminal in raw mode and reads
+key events directly, rendering and redrawing its own prompt line, so background
+writes scroll above the prompt instead of becoming input.
+
+Falls back to plain `input()` when stdin/stdout is not a TTY (pipes, tests),
+where a full-screen line editor can't run anyway.
+"""
+
+from __future__ import annotations
+
+import sys
+from html import escape
+from pathlib import Path
+
+from deepparallel import branding
+
+_HISTORY_PATH = Path.home() / ".deepparallel_history"
+_session = None  # lazily built PromptSession (None until first interactive read)
+
+
+def _get_session():
+    global _session
+    if _session is None:
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.history import FileHistory
+
+        _session = PromptSession(history=FileHistory(str(_HISTORY_PATH)))
+    return _session
+
+
+def _prompt_html(tag: str):
+    """Build the prompt as prompt_toolkit markup: an optional dim mode tag
+    (e.g. '[reason · auto] ') followed by the green 'you ›' prefix."""
+    from prompt_toolkit.formatted_text import HTML
+
+    tag_part = f'<style fg="ansibrightblack">{escape(tag)}</style>' if tag else ""
+    return HTML(f'{tag_part}<b><style fg="ansibrightgreen">you</style></b> › ')
+
+
+def _interactive() -> bool:
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def read_user_input(tag: str = "") -> str:
+    """Read one line from the user. `tag` is an optional prefix shown dimmed
+    before the prompt (the active mode chips). Returns the stripped line.
+
+    Raises EOFError on Ctrl-D and KeyboardInterrupt on Ctrl-C, matching the
+    contract the REPL loops already handle.
+    """
+    if not _interactive():
+        # Non-interactive: a raw-mode editor can't run. Mirror the old prompt.
+        return input(f"{tag}you {branding.ARROW} ").strip()
+    return _get_session().prompt(_prompt_html(tag)).strip()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.4.2
+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

{deepparallel-0.4.2 → deepparallel-0.4.3}/deepparallel.egg-info/SOURCES.txt

@@ -10,8 +10,10 @@ deepparallel/fusion.py
 deepparallel/licensing.py
 deepparallel/registry.json
 deepparallel/renderer.py
+deepparallel/serve.py
 deepparallel/supply_chain.py
 deepparallel/system_prompt.txt
+deepparallel/userinput.py
 deepparallel.egg-info/PKG-INFO
 deepparallel.egg-info/SOURCES.txt
 deepparallel.egg-info/dependency_links.txt
@@ -42,6 +44,7 @@ tests/test_issuer_signer.py
 tests/test_licensing.py
 tests/test_renderer.py
 tests/test_research.py
+tests/test_spinner_color.py
 tests/test_supply_chain.py
 tests/test_tool_registry.py
 tests/test_tools_codeast.py
@@ -51,4 +54,5 @@ tests/test_tools_sandbox.py
 tests/test_tools_search.py
 tests/test_tools_shell.py
 tests/test_tools_vision.py
-tests/test_tools_web.py
+tests/test_tools_web.py
+tests/test_userinput.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.4.2"
+version = "0.4.3"
 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.2 → deepparallel-0.4.3}/tests/test_renderer.py

@@ -86,6 +86,23 @@ def test_rich_welcome_renders_wordmark_and_status(monkeypatch):
     assert "DeepSeek" not in out
 
 
+def test_rich_welcome_narrow_pane_uses_compact_banner(monkeypatch):
+    import deepparallel.renderer as rmod
+
+    monkeypatch.setattr(rmod, "_REVEAL_SECONDS", 0)
+    buf = io.StringIO()
+    # narrower than the 71-col block wordmark: it would wrap and shatter
+    con = Console(no_color=True, width=46, file=buf, force_terminal=True, highlight=False)
+    rmod.RichRenderer(console=con).welcome("Azure @ https://x", version="0.4.2", tool_count=15)
+    out = buf.getvalue()
+    assert "◆ DeepParallel" in out  # compact one-line mark
+    # the block wordmark's first row must NOT appear (no shattered letters)
+    assert "████  █████ █████" not in out
+    # no line exceeds the pane width (nothing wraps/shatters)
+    visible = [line for line in out.replace("\x1b[1m", "").replace("\x1b[0m", "").split("\n")]
+    assert max((len(line) for line in visible), default=0) <= 46
+
+
 def test_rich_tool_timer_path_renders_card(monkeypatch):
     buf = io.StringIO()
     con = Console(no_color=True, width=80, file=buf, force_terminal=True, highlight=False)
@@ -160,13 +177,17 @@ def test_rich_answer_stream_renders_markdown_formatting():
     assert "# Big" not in out
 
 
-def test_rich_answer_stream_empty_prints_nothing():
+def test_rich_answer_stream_empty_renders_no_answer_panel():
+    # A tool-only turn (empty content stream) shows only the transient thinking
+    # spinner, which clears itself - it must not render an answer body and must
+    # leave nothing permanent (Live transient erases its line on exit).
     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([]))
     assert full == ""
-    assert buf.getvalue() == ""  # tool-only turns never start the live panel
+    out = buf.getvalue()
+    assert "\x1b[2K" in out or out == ""  # transient spinner erased its own line
 
 
 def test_rich_answer_stream_whitespace_leading_holds_panel():
@@ -237,3 +258,44 @@ def test_fake_confirm_scripted():
     assert f.confirm("a", "d") is True
     assert f.confirm("b", "d") is False
     assert ("confirm", "a", "d") in f.calls
+
+
+# ---------------------------------------------------- answer_stream + spinner
+def test_rich_answer_stream_returns_full_text_with_spinner_path():
+    # forced terminal -> the transient thinking-spinner path runs; it must not
+    # corrupt the returned text or swallow content.
+    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(["Hello ", "world", "\n\ndone"]))
+    assert full == "Hello world\n\ndone"
+    out = buf.getvalue()
+    assert "Hello world" in out and "done" in out
+
+
+def test_rich_answer_stream_non_terminal_shows_no_spinner():
+    r, buf = _rich()  # StringIO console: is_terminal is False
+    full = r.answer_stream(iter(["a", "b", "c"]))
+    assert full == "abc"
+    assert "thinking" not in buf.getvalue()
+
+
+def test_thinking_spinner_animates_and_is_branded():
+    from deepparallel import branding
+
+    sp = branding.thinking_spinner("reasoning")
+    f0 = sp.frame(0).plain
+    f3 = sp.frame(3).plain
+    assert f0.startswith(branding.MARK)  # anchored by the diamond mark
+    assert "reasoning…" in f0
+    assert any(b in f0 for b in branding._PULSE_BLOCKS)  # parallel lanes present
+    assert f0 != f3  # the crest travels: distinct frames over time
+
+
+def test_thinking_spinner_rich_protocol_advances_frame():
+    from deepparallel import branding
+
+    sp = branding.thinking_spinner()
+    a = sp.__rich__().plain
+    b = sp.__rich__().plain
+    assert a != b  # each render is a new frame (Live animates by re-rendering)

deepparallel-0.4.3/tests/test_spinner_color.py

@@ -0,0 +1,45 @@
+"""The thinking spinner drifts its crest color over time while keeping the
+travelling-pulse motion. These tests pin the color-drift behavior without needing
+a live terminal, since `frame()` is pure."""
+
+from deepparallel import branding
+
+
+def _crest_style(text):
+    """The ◆ mark is always the live crest hue; return its style string."""
+    # first span covers the "◆ " mark
+    return str(text.spans[0].style)
+
+
+def test_crest_color_drifts_across_ticks():
+    sp = branding.thinking_spinner()
+    early = _crest_style(sp.frame(0))
+    later = _crest_style(sp.frame(40))
+    assert early != later, "crest hue should change as the spinner works"
+
+
+def test_crest_color_cycles_back():
+    # The continuous hue function loops every len(_CREST_PALETTE) phase units.
+    # (The spinner samples this at discrete ticks, which need not divide evenly,
+    # so the invariant lives on the pure function, not the integer-tick frame.)
+    n = len(branding._CREST_PALETTE)
+    assert branding._crest_color(0.0) == branding._crest_color(float(n))
+    assert branding._crest_color(1.3) == branding._crest_color(1.3 + n)
+
+
+def test_frame_is_pure():
+    sp = branding.thinking_spinner()
+    assert str(sp.frame(7)) == str(sp.frame(7))  # same tick -> identical frame
+
+
+def test_lerp_hex_endpoints_and_midpoint():
+    assert branding._lerp_hex("#000000", "#ffffff", 0.0) == "#000000"
+    assert branding._lerp_hex("#000000", "#ffffff", 1.0) == "#ffffff"
+    assert branding._lerp_hex("#000000", "#ffffff", 0.5) == "#808080"
+
+
+def test_crest_color_always_valid_hex():
+    for tick in range(0, 200, 3):
+        c = branding._crest_color(tick * 0.06)
+        assert c.startswith("#") and len(c) == 7
+        int(c[1:], 16)  # parses as hex

deepparallel-0.4.3/tests/test_userinput.py

@@ -0,0 +1,40 @@
+import builtins
+
+from deepparallel import userinput
+
+
+def test_non_interactive_falls_back_to_input_and_strips(monkeypatch):
+    monkeypatch.setattr(userinput, "_interactive", lambda: False)
+    monkeypatch.setattr(builtins, "input", lambda prompt="": "  hello there  ")
+    assert userinput.read_user_input() == "hello there"
+
+
+def test_non_interactive_prompt_includes_tag(monkeypatch):
+    captured = {}
+
+    def fake_input(prompt=""):
+        captured["prompt"] = prompt
+        return "do the thing\n"
+
+    monkeypatch.setattr(userinput, "_interactive", lambda: False)
+    monkeypatch.setattr(builtins, "input", fake_input)
+    out = userinput.read_user_input("[reason · auto] ")
+    assert out == "do the thing"
+    assert "[reason · auto]" in captured["prompt"]
+
+
+def test_interactive_path_uses_prompt_session(monkeypatch):
+    class FakeSession:
+        def prompt(self, _formatted):
+            return "  typed input  "
+
+    monkeypatch.setattr(userinput, "_interactive", lambda: True)
+    monkeypatch.setattr(userinput, "_get_session", lambda: FakeSession())
+    assert userinput.read_user_input("[deep] ") == "typed input"
+
+
+def test_prompt_html_escapes_tag(monkeypatch):
+    # a tag must not be able to inject prompt_toolkit markup
+    html = userinput._prompt_html("<b>x</b> ")
+    assert "&lt;b&gt;" in html.value
+    assert "you" in html.value

deepparallel-0.4.2/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, 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.